diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdiadaptation/swsrc/swdirectgdipolygon.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdiadaptation/swsrc/swdirectgdipolygon.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1319 @@
+// Copyright (c) 2007-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 "swdirectgdipolygon.h"
+
+/**
+A utility class used to sort vertex lists based on y coordinates.
+@see CSwDirectGdiPolygonFiller
+@see TKey
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TCompareEdgesUpperY) : public TKey
+	{
+public:
+	TCompareEdgesUpperY(const CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual TInt Compare(TInt aLeft,TInt aRight) const;
+private:
+	const CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TCompareEdgesUpperY::TCompareEdgesUpperY(const CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Compare edges based on their upper Y coordinate.
+
+@param aLeft Index corresponding to the "left" side of the comparison. 
+@param aRight Index corresponding to the "right" side of the comparison.
+
+@return Zero, if the two keys are equal; negative, if the left key is less than the right key; positive, if the left key is greater than the right key.
+
+@see TKey::Compare
+*/
+TInt TCompareEdgesUpperY::Compare(TInt aLeft,TInt aRight) const
+	{
+	const TInt leftUpperY=iFastData.vertexList[iFastData.edgeList[aLeft].upperVertex].iY;
+	const TInt rightUpperY=iFastData.vertexList[iFastData.edgeList[aRight].upperVertex].iY;
+	if (leftUpperY<rightUpperY)
+		return -1;
+	if (leftUpperY>rightUpperY)
+		return 1;
+	return 0;
+	}
+
+/**
+A utility class used to swap entries in edgeList arrays during sort operations.
+@see CSwDirectGdiPolygonFiller
+@see TSwap
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TSwapEdges) : public TSwap
+	{
+public:
+	TSwapEdges(CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual void Swap(TInt aLeft,TInt aRight) const;
+private:
+	CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TSwapEdges::TSwapEdges(CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Swaps two elements of an edgeList array. 
+
+@param aLeft The index of an array element participating in the swap. 
+@param aRight The index of an array element participating in the swap.
+
+@see TSwap::Swap
+*/
+void TSwapEdges::Swap(TInt aLeft,TInt aRight) const
+	{
+	CSwDirectGdiPolygonFiller::SFastEdge& leftEdge=iFastData.edgeList[aLeft];
+	CSwDirectGdiPolygonFiller::SFastEdge& rightEdge=iFastData.edgeList[aRight];
+
+	const CSwDirectGdiPolygonFiller::SFastEdge temp(leftEdge);
+	leftEdge=rightEdge;
+	rightEdge=temp;
+	}
+
+/**
+A utility class used to sort active edge lists based on the order of their vertexes.
+@see CSwDirectGdiPolygonFiller
+@see TKey
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TCompareActiveEdgesFirstVertex) : public TKey
+	{
+public:
+	TCompareActiveEdgesFirstVertex(const CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual TInt Compare(TInt aLeft,TInt aRight) const;
+private:
+	const CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TCompareActiveEdgesFirstVertex::TCompareActiveEdgesFirstVertex(const CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Compare edges based on the order of their vertexes.
+
+@param aLeft Index corresponding to the "left" side of the comparison. 
+@param aRight Index corresponding to the "right" side of the comparison.
+
+@return Zero, if the two keys are equal; negative, if the left key is less than the right key; positive, if the left key is greater than the right key.
+
+@see TKey::Compare
+*/
+TInt TCompareActiveEdgesFirstVertex::Compare(TInt aLeft,TInt aRight) const
+	{
+	const TInt leftFirstVertex=iFastData.activeEdgeList[aLeft].edgePtr->firstVertex;
+	const TInt rightFirstVertex=iFastData.activeEdgeList[aRight].edgePtr->firstVertex;
+	if (leftFirstVertex<rightFirstVertex)
+		return -1;
+	if (leftFirstVertex>rightFirstVertex)
+		return 1;
+	return 0;
+	}
+
+/**
+A utility class used to swap entries in activeEdgeList arrays during sort operations.
+@see CSwDirectGdiPolygonFiller
+@see TSwap
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TSwapActiveEdges) : public TSwap
+	{
+public:
+	TSwapActiveEdges(CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual void Swap(TInt aLeft,TInt aRight) const;
+private:
+	CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TSwapActiveEdges::TSwapActiveEdges(CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Swaps two elements of an activeEdgeList array. 
+@param aLeft The index of an array element participating in the swap. 
+@param aRight The index of an array element participating in the swap.
+@see TSwap::Swap
+*/
+void TSwapActiveEdges::Swap(TInt aLeft,TInt aRight) const
+	{
+	CSwDirectGdiPolygonFiller::SFastActiveEdge& leftActiveEdge=iFastData.activeEdgeList[aLeft];
+	CSwDirectGdiPolygonFiller::SFastActiveEdge& rightActiveEdge=iFastData.activeEdgeList[aRight];
+
+	const CSwDirectGdiPolygonFiller::SFastActiveEdge temp(leftActiveEdge);
+	leftActiveEdge=rightActiveEdge;
+	rightActiveEdge=temp;
+
+	if (leftActiveEdge.scanLineIntersectionPtr!=NULL)
+		leftActiveEdge.scanLineIntersectionPtr->activeEdgePtr=&leftActiveEdge;
+	if (rightActiveEdge.scanLineIntersectionPtr!=NULL)
+		rightActiveEdge.scanLineIntersectionPtr->activeEdgePtr=&rightActiveEdge;
+	}
+
+/**
+A utility class used to sort intersection lists based on the position of their first pixel.
+@see CSwDirectGdiPolygonFiller
+@see TKey
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TCompareScanLineIntersectionsFirstPixel) : public TKey
+	{
+public:
+	TCompareScanLineIntersectionsFirstPixel(const CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual TInt Compare(TInt aLeft,TInt aRight) const;
+private:
+	const CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TCompareScanLineIntersectionsFirstPixel::TCompareScanLineIntersectionsFirstPixel(const CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Compare intersections based on the order of their first pixel.
+
+@param aLeft Index corresponding to the "left" side of the comparison. 
+@param aRight Index corresponding to the "right" side of the comparison.
+
+@return Zero, if the two keys are equal; negative, if the left key is less than the right key; positive, if the left key is greater than the right key.
+
+@see TKey::Compare
+*/
+TInt TCompareScanLineIntersectionsFirstPixel::Compare(TInt aLeft,TInt aRight) const
+	{
+	const TInt leftFirstPixel=iFastData.scanLineIntersectionList[aLeft].firstPixel;
+	const TInt rightFirstPixel=iFastData.scanLineIntersectionList[aRight].firstPixel;
+	if (leftFirstPixel<rightFirstPixel)
+		return -1;
+	if (leftFirstPixel>rightFirstPixel)
+		return 1;
+	return 0;
+	}
+
+/**
+A utility class used to swap entries in intersection list arrays during sort operations.
+@see CSwDirectGdiPolygonFiller
+@see TSwap
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TSwapScanLineIntersections) : public TSwap
+	{
+public:
+	TSwapScanLineIntersections(CSwDirectGdiPolygonFiller::SFastData& aFastData);
+private:
+	virtual void Swap(TInt aLeft,TInt aRight) const;
+private:
+	CSwDirectGdiPolygonFiller::SFastData& iFastData;
+	};
+
+TSwapScanLineIntersections::TSwapScanLineIntersections(CSwDirectGdiPolygonFiller::SFastData& aFastData):
+	iFastData(aFastData)
+	{
+	}
+
+/**
+Swaps two elements of a scanLineIntersectionList array. 
+@param aLeft The index of an array element participating in the swap. 
+@param aRight The index of an array element participating in the swap.
+@see TSwap::Swap
+*/
+void TSwapScanLineIntersections::Swap(TInt aLeft,TInt aRight) const
+	{
+	CSwDirectGdiPolygonFiller::SFastScanLineIntersection& leftScanLineIntersection=iFastData.scanLineIntersectionList[aLeft];
+	CSwDirectGdiPolygonFiller::SFastScanLineIntersection& rightScanLineIntersection=iFastData.scanLineIntersectionList[aRight];
+
+	const CSwDirectGdiPolygonFiller::SFastScanLineIntersection temp(leftScanLineIntersection);
+	leftScanLineIntersection=rightScanLineIntersection;
+	rightScanLineIntersection=temp;
+
+	leftScanLineIntersection.activeEdgePtr->scanLineIntersectionPtr=&leftScanLineIntersection;
+	rightScanLineIntersection.activeEdgePtr->scanLineIntersectionPtr=&rightScanLineIntersection;
+	}
+
+/**
+Sorts array elements
+
+@param aCount The number of elements in the array.
+@param aKey A reference to a suitably initialised TKey derived object.
+@param aSwap A reference to a suitably initialised TSwap derived object.
+@panic DGDIAdapter 1015, if QuickSort failed.
+
+@internalComponent
+*/
+LOCAL_C void Sort(TInt aCount,const TKey& aKey,const TSwap& aSwap)
+	{
+#if 1 // quick sort
+	const TInt error=User::QuickSort(aCount,aKey,aSwap);
+	GRAPHICS_ASSERT_ALWAYS(error==KErrNone, EDirectGdiPanicPolygonFiller);
+#elif 0 // bubble sort
+	for (TInt i=1; i<aCount; ++i)
+		{
+		for (TInt j=i; j>0; --j)
+			{
+			if (aKey.Compare(j-1,j)>0)
+				{
+				aSwap.Swap(j-1,j);
+				}
+			}
+		}
+#else // heap sort
+	TInt startOfSortedPortion=aCount;
+	if (startOfSortedPortion>1)
+		{
+		TInt startOfHeap=startOfSortedPortion>>1;
+		FOREVER
+			{
+			GRAPHICS_ASSERT_DEBUG(startOfHeap>=0, EDirectGdiPanicPolygonFiller);
+			if (startOfHeap!=0)
+				{
+				--startOfHeap;
+				}
+			else
+				{
+				--startOfSortedPortion;
+				aSwap.Swap(startOfSortedPortion,0);
+				GRAPHICS_ASSERT_DEBUG(startOfSortedPortion>=1, EDirectGdiPanicPolygonFiller);
+				if (startOfSortedPortion==1)
+					{
+					break;
+					}
+				}
+			// put aArray[startOfHeap] into the correct place in the heap
+			TInt i=startOfHeap;
+			FOREVER
+				{
+				TInt j=(i+1)<<1;
+				if ((j>=startOfSortedPortion) || (aKey.Compare(j-1,j)>0))
+					{
+					--j;
+					}
+				if ((j>=startOfSortedPortion) || (aKey.Compare(i,j)>=0))
+					{
+					break;
+					}
+				aSwap.Swap(i,j);
+				i=j;
+				}
+			}
+		}
+#endif
+#if defined(_DEBUG)
+	{
+	for (TInt i=1; i<aCount; ++i)
+		{
+		GRAPHICS_ASSERT_DEBUG(aKey.Compare(i-1,i)<=0, EDirectGdiPanicPolygonFiller);
+		}
+	}
+#endif
+	}
+
+/*
+ CSwDirectGdiPolygonFiller
+ */
+ 
+/**
+ Constructor which initialises all member data to zero, EFalse or null for 
+ TInt, TBool pointers respectively.
+ */
+CSwDirectGdiPolygonFiller::CSwDirectGdiPolygonFiller():
+	CBase(),
+	iPointArray(NULL),
+	iFillRule(DirectGdi::EAlternate),
+	iUseFastAlgorithm(EFalse),
+	iNumVertexes(0),
+	iToggler(EFalse),
+	iNestingLevel(0),
+	iScanLineIntersection(0),
+	iRightMostPixelOnScanLine(0),
+	iFirstVertex(0),
+	iPolygonIsAllHorizontal(EFalse),
+	iFirstScanLine(0),
+	iLastScanLine(0),
+	iCurrentScanLine(0)
+	{
+	iFastData.vertexList=NULL;
+	iFastData.edgeList=NULL;
+	iFastData.activeEdgeList=NULL;
+	iFastData.scanLineIntersectionList=NULL;
+	iFastData.numActiveEdges=0;
+	iFastData.numScanLineIntersections=0;
+	iFastData.nextEdgeToActivate=0;
+	iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet=0;
+	iSlowData.numIntersectionsWithSameFirstPixelMetThisTime=0;
+	iSlowData.numScanLineIntersections=0;
+	iSlowData.scanLineComplete=EFalse;
+	iSlowData.firstPixelOfLastIntersectionInPrevBuffer=0;
+	}
+
+/**
+Destructor calls reset on the polygon.
+*/
+CSwDirectGdiPolygonFiller::~CSwDirectGdiPolygonFiller()
+	{
+	Reset();
+	}
+
+/**
+An overloaded version of Construct which allows the list of points to be passed in as a point array.
+Exactly the same behaviour and structure as above. This should not fail. This method does not require the 
+number of nodes to be given as a parameter.
+
+@param aPointArray A pointer to point array, as opposed to a pointer to a point list.
+@param aFillRule How filling should be achieved, as described by a DirectGdi::TFillRule object.
+@param aUsage How the polygon should be used.
+@panic DGDIAdapter 1015, if aPointArray is NULL.
+*/
+void CSwDirectGdiPolygonFiller::Construct(const TArray<TPoint>* aPointArray, 
+										DirectGdi::TFillRule aFillRule, TUsage aUsage)
+	{
+	GRAPHICS_ASSERT_ALWAYS(aPointArray!=NULL,EDirectGdiPanicPolygonFiller);
+	iPointArray=aPointArray;
+	iNumVertexes=iPointArray->Count();
+	Construct(aFillRule,aUsage);
+	}
+
+/**
+Builds up the internal meta-data needed to fill the polygon.
+
+@param aFillRule How filling should be achieved, as described by a DirectGdi::TFillRule object.
+@param aUsage How the polygon should be used, see TUsage enumeration.
+@panic DGDIAdapter 1015, if aFillRule is invalid, or aUsage is invalid. 
+*/
+void CSwDirectGdiPolygonFiller::Construct(DirectGdi::TFillRule aFillRule, TUsage aUsage)
+	{
+	GRAPHICS_ASSERT_ALWAYS((aFillRule==DirectGdi::EAlternate) || (aFillRule==DirectGdi::EWinding),
+																					EDirectGdiPanicPolygonFiller);
+	GRAPHICS_ASSERT_ALWAYS((aUsage==EGetAllPixelRunsSequentially) || (aUsage==EGetPixelRunsSequentiallyForSpecifiedScanLines),
+																					EDirectGdiPanicPolygonFiller);
+	TInt i, j;
+	iFillRule=aFillRule;
+	iUseFastAlgorithm=(aUsage==EGetAllPixelRunsSequentially);
+	iToggler=EFalse;
+	iNestingLevel=0;
+	iScanLineIntersection=0;
+	iRightMostPixelOnScanLine=KMinTInt;
+	// find the first vertex and see if the polygon is all horizontal
+	iFirstVertex=0; // dummy default value
+	iPolygonIsAllHorizontal=ETrue;
+
+	for (i=0; i<iNumVertexes; ++i)
+		if (Point(i).iY!=Point((i+1)%iNumVertexes).iY)
+			{
+			// i is now set to the vertex before the first non-horizontal edge
+
+			// set j%iNumVertexes to the vertex before the next non-horizontal edge
+			for (j=i+1; Point(j%iNumVertexes).iY==Point((j+1)%iNumVertexes).iY; ++j)
+				;
+			j%=iNumVertexes;
+			TInt first=Point(i).iY;
+			TInt middle=Point(j).iY;
+			TInt last=Point((j+1)%iNumVertexes).iY;
+
+			// if vertex j is a max or min point, set the first-vertex to be j
+			if ((middle<first)==(middle<last))
+				{
+				iFirstVertex=j;
+				iPolygonIsAllHorizontal=EFalse;
+				break;
+				}
+			}
+
+	if (iUseFastAlgorithm)
+		{
+		iFastData.vertexList=(TPoint*)User::Alloc(sizeof(TPoint)*iNumVertexes);
+		iFastData.edgeList=(SFastEdge*)User::Alloc(sizeof(SFastEdge)*iNumVertexes);
+		iFastData.activeEdgeList=(SFastActiveEdge*)User::Alloc(sizeof(SFastActiveEdge)*iNumVertexes);
+		iFastData.scanLineIntersectionList=(SFastScanLineIntersection*)User::Alloc(sizeof(SFastScanLineIntersection)*iNumVertexes);
+		if ((iFastData.vertexList==NULL) ||
+			(iFastData.edgeList==NULL) ||
+			(iFastData.activeEdgeList==NULL) ||
+			(iFastData.scanLineIntersectionList==NULL))
+			{
+			Reset(); // sets iUseFastAlgorithm to EFalse among other things
+			}
+		}
+	
+	if (iUseFastAlgorithm)
+		{
+		for(TInt vertexcount=0;vertexcount<iNumVertexes;vertexcount++)
+			new(&iFastData.activeEdgeList[vertexcount]) SFastActiveEdge;
+		iFastData.numActiveEdges=0;
+		iFastData.numScanLineIntersections=0;
+		iFastData.nextEdgeToActivate=0;
+
+		// put the points into the vertex-list
+		// N.B. this array is used for speed since CArrayXxxs are slower for indexing into than built-in arrays
+		for (i=0; i<iNumVertexes; ++i)
+			{
+			// If iFastData.vertexList is NULL this will never be run. iFastData.vertexList is checked 
+			// above after which iUseFastAlgorithm is set to EFalse if it is NULL (in Reset())
+			// coverity[var_deref_op]
+			iFastData.vertexList[i]=Point((i+iFirstVertex)%iNumVertexes);
+			}
+
+		// create edge-list
+		for (i=0; i<iNumVertexes; ++i)
+			{
+			// See preceding coverity comment
+			// coverity[var_deref_op]
+			if (iFastData.vertexList[i].iY<iFastData.vertexList[(i+1)%iNumVertexes].iY)
+				{
+				iFastData.edgeList[i].upperVertex=i;
+				iFastData.edgeList[i].lowerVertex=(i+1)%iNumVertexes;
+				}
+			else
+				{
+				iFastData.edgeList[i].upperVertex=(i+1)%iNumVertexes;
+				iFastData.edgeList[i].lowerVertex=i;
+				}
+			iFastData.edgeList[i].firstVertex=i;
+			}
+
+		// sort edge-list into order of increasing upper y-position
+		Sort(iNumVertexes,TCompareEdgesUpperY(iFastData),TSwapEdges(iFastData));
+
+		// find the first scan-line
+		iFirstScanLine=iFastData.vertexList[iFastData.edgeList[0].upperVertex].iY;
+
+		// find the last scan-line
+		iLastScanLine=iFirstScanLine;
+		for (i=0; i<iNumVertexes; ++i)
+			if (iLastScanLine<iFastData.vertexList[i].iY)
+				iLastScanLine=iFastData.vertexList[i].iY;
+		}
+	else
+		{
+		iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet=0;
+		iSlowData.scanLineComplete=EFalse;
+		iSlowData.firstPixelOfLastIntersectionInPrevBuffer=KMinTInt;
+
+		// find the first and last scan-lines
+		iFirstScanLine=KMaxTInt;
+		iLastScanLine=KMinTInt;
+		for (i=0; i<iNumVertexes; ++i)
+			{
+			TInt y=Point(i).iY;
+			if (iFirstScanLine>y)
+				iFirstScanLine=y;
+			if (iLastScanLine<y)
+				iLastScanLine=y;
+			}
+		}
+
+	iCurrentScanLine=iFirstScanLine;
+	}
+
+/**
+Frees any data held in the polygon’s lists of edges, vertexes and scan lines, and sets these values to NULL.
+It also has the feature of setting iUseFastAlgorithm = EFalse.
+*/
+void CSwDirectGdiPolygonFiller::Reset()
+	{
+	if(iUseFastAlgorithm)
+		{
+		if(iFastData.vertexList)
+			{
+			User::Free(iFastData.vertexList);
+			iFastData.vertexList=NULL;
+			}
+		if(iFastData.edgeList)
+			{
+			User::Free(iFastData.edgeList);
+			iFastData.edgeList=NULL;
+			}
+		if(iFastData.activeEdgeList)
+			{
+			User::Free(iFastData.activeEdgeList);
+			iFastData.activeEdgeList=NULL;
+			}
+		if(iFastData.scanLineIntersectionList)
+			{
+			User::Free(iFastData.scanLineIntersectionList);
+			iFastData.scanLineIntersectionList=NULL;
+			}
+		iUseFastAlgorithm=EFalse;
+		}
+	}
+
+/**
+Method is used to calculate the locations of vertex interactions between the polygon and scan lines. 
+An initial scan line is required. It calculates the start and end positions on the line. The method
+can use either the fast or slow polygon algorithm depending upon the state of aUsage. Polygon filling
+is also addressed by this method.
+
+@param aExists Will be set to EFalse if a polygon with no vertexes is passed in, otherwise ETrue on return.
+@param aScanLine On return will contain iScanline at the beginning of the operation.
+@param aStart On return, contains the position on the scan line to start the run.
+@param aEnd On return, contains the position on the scan line to end the run.
+@panic DGDIAdapter 1015 (debug only)
+*/
+void CSwDirectGdiPolygonFiller::GetNextPixelRun(TBool& aExists, TInt& aScanLine, TInt& aStart, 
+											  TInt& aEnd)
+	{
+	if (iCurrentScanLine>iLastScanLine)
+		{
+		aExists=EFalse;
+		return;
+		}
+
+	aExists=ETrue;
+	aScanLine=iCurrentScanLine;
+
+	if (iPolygonIsAllHorizontal)
+		{
+		// set the start after the end
+		aStart=KMinTInt+1;
+		aEnd=KMinTInt;
+		++iCurrentScanLine;
+		return;
+		}
+
+	if (iUseFastAlgorithm)
+		{
+		TInt i, j;
+
+		if (iScanLineIntersection==0)
+			{
+			// add any new edges to the active-edge-list
+			for (; (iFastData.nextEdgeToActivate<iNumVertexes) &&
+					(iFastData.vertexList[iFastData.edgeList[iFastData.nextEdgeToActivate].upperVertex].iY==iCurrentScanLine);
+					++iFastData.numActiveEdges, ++iFastData.nextEdgeToActivate)
+				{
+				iFastData.activeEdgeList[iFastData.numActiveEdges].edgePtr=&iFastData.edgeList[iFastData.nextEdgeToActivate];
+				iFastData.activeEdgeList[iFastData.numActiveEdges].lineGenerator.Construct(
+														iFastData.vertexList[iFastData.edgeList[iFastData.nextEdgeToActivate].upperVertex],
+														iFastData.vertexList[iFastData.edgeList[iFastData.nextEdgeToActivate].lowerVertex]);
+				iFastData.activeEdgeList[iFastData.numActiveEdges].scanLineIntersectionPtr=NULL;
+				}
+
+			// sort the active-edge-list into order of adjacent edges (if possible)
+			Sort(iFastData.numActiveEdges,TCompareActiveEdgesFirstVertex(iFastData),TSwapActiveEdges(iFastData));
+
+			// find the intersection of each active-edge with the current scan-line
+			// for max/min vertex-runs (e.g. \/, \_/, \__/, etc.) add 2 intersections for each run
+			// for other vertex-runs (e.g. /----/) add 1 intersection for each run
+			for (i=0; i<iFastData.numActiveEdges; ++i)
+				{
+				// check that active-edge i is not horizontal
+				GRAPHICS_ASSERT_DEBUG(iFastData.vertexList[iFastData.activeEdgeList[i].edgePtr->upperVertex].iY!=
+							   iFastData.vertexList[iFastData.activeEdgeList[i].edgePtr->lowerVertex].iY, EDirectGdiPanicPolygonFiller);
+
+				if (iFastData.vertexList[iFastData.activeEdgeList[i].edgePtr->upperVertex].iY==iCurrentScanLine)
+					// the scan-line is intersecting active-edge i at its upper-vertex
+					FastHandleVertexIntersection(i, EFalse);
+				else if (iFastData.vertexList[iFastData.activeEdgeList[i].edgePtr->lowerVertex].iY==iCurrentScanLine)
+					// the scan-line is intersecting active-edge i at its lower-vertex
+					FastHandleVertexIntersection(i, ETrue);
+				else
+					// the scan-line is intersecting active-edge i at neither of its vertexes
+					SetFastIntersection(iFastData.activeEdgeList[i],*iFastData.activeEdgeList[i].scanLineIntersectionPtr);
+				}
+
+			// N.B. iFastData.numScanLineIntersections is less than or equal to iFastData.numActiveEdges
+
+			// sort the intersection-list into increasing order of first-pixel
+			Sort(iFastData.numScanLineIntersections,TCompareScanLineIntersectionsFirstPixel(iFastData),TSwapScanLineIntersections(iFastData));
+
+			GRAPHICS_ASSERT_DEBUG(iFastData.numScanLineIntersections>=2, EDirectGdiPanicPolygonFiller);
+			}
+
+		// depending on the rule used, find the pixel-run
+		TBool doFill=EFalse; // dummy initialization to prevent compiler warning
+		if (iScanLineIntersection<iFastData.numScanLineIntersections-1)
+			{
+			switch (iFillRule)
+				{
+			case DirectGdi::EAlternate:
+				iToggler=!iToggler;
+				doFill=iToggler;
+				break;
+			case DirectGdi::EWinding:
+					GRAPHICS_ASSERT_DEBUG(iFastData.vertexList[iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->lowerVertex].iY!=
+								   iFastData.vertexList[iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->upperVertex].iY,
+																										EDirectGdiPanicPolygonFiller);
+
+					if (iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->lowerVertex==
+						(iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->upperVertex+1)%iNumVertexes)
+						++iNestingLevel;
+					else
+						--iNestingLevel;
+
+				doFill=(iNestingLevel!=0);
+				break;
+				}
+
+			if (doFill)
+				{
+				aStart=Max(iRightMostPixelOnScanLine, iFastData.scanLineIntersectionList[iScanLineIntersection].lastPixel)+1;
+				aEnd=iFastData.scanLineIntersectionList[iScanLineIntersection+1].firstPixel-1;
+				}
+			else
+				{
+				// set the start after the end
+				aStart=KMinTInt+1;
+				aEnd=KMinTInt;
+				}
+
+			if (iRightMostPixelOnScanLine<iFastData.scanLineIntersectionList[iScanLineIntersection].lastPixel)
+				iRightMostPixelOnScanLine=iFastData.scanLineIntersectionList[iScanLineIntersection].lastPixel;
+			++iScanLineIntersection;
+			}
+
+		if (iScanLineIntersection==iFastData.numScanLineIntersections-1)
+			{
+			GRAPHICS_ASSERT_DEBUG(iFastData.vertexList[iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->lowerVertex].iY!=
+						   iFastData.vertexList[iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->upperVertex].iY,
+																											EDirectGdiPanicPolygonFiller);
+
+			switch (iFillRule)
+				{
+			case DirectGdi::EAlternate:
+				iToggler=!iToggler;
+				GRAPHICS_ASSERT_DEBUG(iToggler==0, EDirectGdiPanicPolygonFiller);
+				break;
+			case DirectGdi::EWinding:
+				if (iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->lowerVertex==
+					(iFastData.scanLineIntersectionList[iScanLineIntersection].activeEdgePtr->edgePtr->upperVertex+1)%iNumVertexes)
+					++iNestingLevel;
+				else
+					--iNestingLevel;
+				GRAPHICS_ASSERT_DEBUG((iNumVertexes==2) || (iNestingLevel==0), EDirectGdiPanicPolygonFiller);
+				break;
+				}
+
+			// remove any scan-line-intersections associated with old active-edges
+			for (i=0; i<iFastData.numScanLineIntersections; )
+				if (iFastData.vertexList[iFastData.scanLineIntersectionList[i].activeEdgePtr->edgePtr->lowerVertex].iY==iCurrentScanLine)
+					{
+					iFastData.scanLineIntersectionList[i].activeEdgePtr->scanLineIntersectionPtr=NULL;
+
+					// ripple all the entries in the scan-line-intersection-list after this one back one place
+					for (j=i+1; j<iFastData.numScanLineIntersections; ++j)
+						{
+						iFastData.scanLineIntersectionList[j-1]=iFastData.scanLineIntersectionList[j];
+						iFastData.scanLineIntersectionList[j-1].activeEdgePtr->scanLineIntersectionPtr=&iFastData.scanLineIntersectionList[j-1];
+						}
+
+					iFastData.scanLineIntersectionList[j-1].activeEdgePtr=NULL;
+					--iFastData.numScanLineIntersections;
+					}
+				else
+					++i;
+
+			// remove any old edges from the active-edge-list
+			for (i=0; i<iFastData.numActiveEdges; )
+				if (iFastData.vertexList[iFastData.activeEdgeList[i].edgePtr->lowerVertex].iY==iCurrentScanLine)
+					{
+					GRAPHICS_ASSERT_DEBUG(iFastData.activeEdgeList[i].scanLineIntersectionPtr==NULL, EDirectGdiPanicPolygonFiller);
+
+					// ripple all the entries in the active-edge-list after this one back one place
+					for (j=i+1; j<iFastData.numActiveEdges; ++j)
+						{
+						iFastData.activeEdgeList[j-1]=iFastData.activeEdgeList[j];
+						if (iFastData.activeEdgeList[j-1].scanLineIntersectionPtr)
+							iFastData.activeEdgeList[j-1].scanLineIntersectionPtr->activeEdgePtr=&iFastData.activeEdgeList[j-1];
+						}
+
+					iFastData.activeEdgeList[j-1].scanLineIntersectionPtr=NULL;
+					--iFastData.numActiveEdges;
+					}
+				else
+					++i;
+
+#if defined(_DEBUG)
+			for (i=0; i<iFastData.numActiveEdges; ++i)
+				{
+				GRAPHICS_ASSERT_DEBUG(iFastData.activeEdgeList[i].scanLineIntersectionPtr->activeEdgePtr==
+								&iFastData.activeEdgeList[i], EDirectGdiPanicPolygonFiller);
+				}
+
+			for (i=0; i<iFastData.numScanLineIntersections; ++i)
+				{
+				GRAPHICS_ASSERT_DEBUG(iFastData.scanLineIntersectionList[i].activeEdgePtr->scanLineIntersectionPtr==
+								&iFastData.scanLineIntersectionList[i], EDirectGdiPanicPolygonFiller);
+				}
+#endif
+
+			iScanLineIntersection=0;
+			++iCurrentScanLine;
+			iRightMostPixelOnScanLine=KMinTInt;
+			}
+		}
+	else
+		{
+		GetNextPixelRunOnSpecifiedScanLine(aExists, iCurrentScanLine, aStart, aEnd);
+		if (!aExists)
+			GetNextPixelRunOnSpecifiedScanLine(aExists, ++iCurrentScanLine, aStart, aEnd);
+		}
+	}
+
+/**
+Similar to GetNextPixelRun(aExists, aScanLine, aStart, aEnd) this method is used to draw the relevant 
+vertex intersections for a polygon but only for an individual specified scan line. The method
+can use either the fast or slow polygon algorithm depending upon the state of aUsage.
+
+@param aExists Will be set to false if the line does not pass through the polygon or if
+a polygon with no vertexes is specified, otherwise ETrue on return.
+@param aScanLine The scan line to be drawn on. Used to set iScanline
+@param aStart On return, contains the position on the scan line to start the run.
+@param aEnd The position on the scan line to end the run, returned.
+@panic DGDIAdapter 1015, if iUseFastAlgorithm is ETrue (debug only).
+*/
+void CSwDirectGdiPolygonFiller::GetNextPixelRunOnSpecifiedScanLine(TBool& aExists, 
+																 TInt aScanLine, 
+																 TInt& aStart, 
+																 TInt& aEnd)
+	{
+	TInt i, j, k;
+
+	GRAPHICS_ASSERT_DEBUG(!iUseFastAlgorithm, EDirectGdiPanicPolygonFiller);
+
+	if (aScanLine<iCurrentScanLine || aScanLine>iLastScanLine)
+		{
+		aExists=EFalse;
+		return;
+		}
+
+	aExists=ETrue;
+	iCurrentScanLine=aScanLine;
+
+	if (iPolygonIsAllHorizontal)
+		{
+		// set the start after the end
+		aStart=KMinTInt+1;
+		aEnd=KMinTInt;
+		++iCurrentScanLine;
+		return;
+		}
+
+	if (iScanLineIntersection==0)
+		{
+		iSlowData.numIntersectionsWithSameFirstPixelMetThisTime=0;
+		iSlowData.numScanLineIntersections=0;
+		iSlowData.scanLineComplete=ETrue;
+
+		// find the left-most iSlowData::EStoreSize number (or less) of intersections with this scan-line
+		for (i=iFirstVertex; i<iNumVertexes+iFirstVertex; ++i)
+			{
+			TPoint upper=Point(i%iNumVertexes);
+			TPoint lower=Point((i+1)%iNumVertexes);
+			if (upper.iY>lower.iY)
+				{
+				TPoint temp=upper;
+				upper=lower;
+				lower=temp;
+				}
+
+			if ((iCurrentScanLine>=upper.iY) && (iCurrentScanLine<=lower.iY))
+				{
+				// check that the edge starting at vertex i%iNumVertexes is not horizontal
+				GRAPHICS_ASSERT_DEBUG(upper.iY!=lower.iY, EDirectGdiPanicPolygonFiller);
+
+				// step through the line-generator until the current scan-line is reached
+				TPoint startPos, endPos;
+				JumpToCurrentScanLine(iSlowData.lineGenerator, upper, lower, startPos, endPos);
+
+				// find the intersection start and end pixels
+				SSlowScanLineIntersection scanLineIntersection;
+				scanLineIntersection.firstPixel=Min(startPos.iX, endPos.iX);
+				scanLineIntersection.lastPixel=Max(startPos.iX, endPos.iX);
+				scanLineIntersection.firstVertexOfEdge=i%iNumVertexes;
+
+				// handle horizontal runs and minima/maxima
+				if (upper.iY==iCurrentScanLine)
+					SlowHandleVertexIntersection(scanLineIntersection, i, EFalse);
+				else if (lower.iY==iCurrentScanLine)
+					SlowHandleVertexIntersection(scanLineIntersection, i, ETrue);
+
+				// see if there have been other intersections with the same first-pixel
+				if (scanLineIntersection.firstPixel==iSlowData.firstPixelOfLastIntersectionInPrevBuffer)
+					++iSlowData.numIntersectionsWithSameFirstPixelMetThisTime;
+
+				// if the intersection has not already been included in a previous buffer-load
+				if ((scanLineIntersection.firstPixel>iSlowData.firstPixelOfLastIntersectionInPrevBuffer) ||
+					((scanLineIntersection.firstPixel==iSlowData.firstPixelOfLastIntersectionInPrevBuffer) &&
+													(iSlowData.numIntersectionsWithSameFirstPixelMetThisTime>=
+													iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet)))
+					{
+					// put the intersection in the right place in the intersection list (if there is room)
+					for (j=0; j<iSlowData.numScanLineIntersections; ++j)
+						if (scanLineIntersection.firstPixel<iSlowData.scanLineIntersectionList[j].firstPixel)
+							{
+							if (iSlowData.numScanLineIntersections<SSlowData::EStoreSize)
+								++iSlowData.numScanLineIntersections;
+							else
+								iSlowData.scanLineComplete=EFalse;
+
+							for (k=iSlowData.numScanLineIntersections-1; k>j; --k)
+								iSlowData.scanLineIntersectionList[k]=iSlowData.scanLineIntersectionList[k-1];
+							iSlowData.scanLineIntersectionList[j]=scanLineIntersection;
+							break;
+							}
+					if (j==iSlowData.numScanLineIntersections)
+						{
+						if (iSlowData.numScanLineIntersections<SSlowData::EStoreSize)
+							iSlowData.scanLineIntersectionList[iSlowData.numScanLineIntersections++]=scanLineIntersection;
+						else
+							iSlowData.scanLineComplete=EFalse;
+						}
+					}
+				}
+			}
+
+		if (!iSlowData.scanLineComplete)
+			{
+			GRAPHICS_ASSERT_DEBUG(iSlowData.numScanLineIntersections==SSlowData::EStoreSize, EDirectGdiPanicPolygonFiller);
+
+			if (iSlowData.firstPixelOfLastIntersectionInPrevBuffer==iSlowData.scanLineIntersectionList[SSlowData::EStoreSize-1].firstPixel)
+				iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet+=SSlowData::EStoreSize-1;
+			else
+				{
+				iSlowData.firstPixelOfLastIntersectionInPrevBuffer=iSlowData.scanLineIntersectionList[SSlowData::EStoreSize-1].firstPixel;
+				iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet=1;
+				for (i=SSlowData::EStoreSize-1; (i>0) && (iSlowData.firstPixelOfLastIntersectionInPrevBuffer==
+															iSlowData.scanLineIntersectionList[i-1].firstPixel); --i)
+					++iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet;
+				}
+			}
+		}
+
+	// depending on the rule used, find the pixel-run
+	TBool doFill=EFalse; // dummy initialization to prevent compiler warning
+	if (iScanLineIntersection<iSlowData.numScanLineIntersections-1)
+		{
+		switch (iFillRule)
+			{
+		case DirectGdi::EAlternate:
+			iToggler=!iToggler;
+			doFill=iToggler;
+			break;
+		case DirectGdi::EWinding:
+				GRAPHICS_ASSERT_DEBUG(Point(iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge).iY!=
+							   Point((iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge+1)%iNumVertexes).iY,
+																										EDirectGdiPanicPolygonFiller);
+
+				if (Point(iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge).iY>
+					Point((iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge+1)%iNumVertexes).iY)
+					++iNestingLevel;
+				else
+					--iNestingLevel;
+
+			doFill=(iNestingLevel!=0);
+			break;
+			}
+
+		if (doFill)
+			{
+			aStart=Max(iRightMostPixelOnScanLine, iSlowData.scanLineIntersectionList[iScanLineIntersection].lastPixel)+1;
+			aEnd=iSlowData.scanLineIntersectionList[iScanLineIntersection+1].firstPixel-1;
+			}
+		else
+			{
+			// set the start after the end
+			aStart=KMinTInt+1;
+			aEnd=KMinTInt;
+			}
+
+		if (iRightMostPixelOnScanLine<iSlowData.scanLineIntersectionList[iScanLineIntersection].lastPixel)
+			iRightMostPixelOnScanLine=iSlowData.scanLineIntersectionList[iScanLineIntersection].lastPixel;
+		++iScanLineIntersection;
+		}
+
+	if (iScanLineIntersection==iSlowData.numScanLineIntersections-1)
+		{
+		if (iSlowData.scanLineComplete)
+			{
+			GRAPHICS_ASSERT_DEBUG(Point(iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge).iY!=
+						   Point((iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge+1)%iNumVertexes).iY,
+																											EDirectGdiPanicPolygonFiller);
+
+			switch (iFillRule)
+				{
+			case DirectGdi::EAlternate:
+				iToggler=!iToggler;
+				GRAPHICS_ASSERT_DEBUG(iToggler==0, EDirectGdiPanicPolygonFiller);
+				break;
+			case DirectGdi::EWinding:
+				if (Point(iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge).iY>
+					Point((iSlowData.scanLineIntersectionList[iScanLineIntersection].firstVertexOfEdge+1)%iNumVertexes).iY)
+					++iNestingLevel;
+				else
+					--iNestingLevel;
+
+				GRAPHICS_ASSERT_DEBUG((!iSlowData.scanLineComplete) || (iNumVertexes==2) || (iNestingLevel==0), EDirectGdiPanicPolygonFiller);
+				break;
+				}
+			}
+
+		iScanLineIntersection=0;
+		if (iSlowData.scanLineComplete)
+			{
+			++iCurrentScanLine;
+			iRightMostPixelOnScanLine=KMinTInt;
+			iSlowData.numIntersectionsWithSameFirstPixelPreviouslyMet=0;
+			iSlowData.scanLineComplete=EFalse;
+			iSlowData.firstPixelOfLastIntersectionInPrevBuffer=KMinTInt;
+			}
+		}
+	}
+
+/**
+Builds up drawing meta-data in the case where a scanline intersects the active edge at a vertex using
+fast algorithms. 
+
+@param aCurrentActiveEdge Index of the current active edge
+@param aIsLowerVertex If the vertex is the lower vertex ETrue otherwise EFalse.
+@panic DGDIAdapter 1015, if iUseFastAlgorithm is EFalse.
+
+@see GetNextPixelRun()
+*/
+void CSwDirectGdiPolygonFiller::FastHandleVertexIntersection(TInt& aCurrentActiveEdge, 
+												  TBool aIsLowerVertex)
+	{
+	GRAPHICS_ASSERT_DEBUG(iUseFastAlgorithm, EDirectGdiPanicPolygonFiller);
+
+	if (iFastData.vertexList[(iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->firstVertex+1)%iNumVertexes].iY==iCurrentScanLine)
+		// it is the second vertex of active-edge aCurrentActiveEdge that coincides with the current scan-line
+		{
+		TInt origActiveEdge=aCurrentActiveEdge;
+		SFastScanLineIntersection scanLineIntersection;
+		scanLineIntersection.activeEdgePtr=NULL;
+		SetFastIntersection(iFastData.activeEdgeList[origActiveEdge], scanLineIntersection);
+
+		// walk through subsequent adjacent horizontal active-edges
+		FOREVER
+			{
+			// exit the loop if the vertex-run *is* a maximum or a minimum
+			const SFastEdge* tempEdgePtr=iFastData.activeEdgeList[(aCurrentActiveEdge+1)%iFastData.numActiveEdges].edgePtr;
+			TBool isMaxOrMin = EFalse;
+
+			switch(aIsLowerVertex)
+				{
+				case EFalse:
+					isMaxOrMin = (iFastData.vertexList[tempEdgePtr->lowerVertex].iY > iCurrentScanLine);
+					break;
+
+				case ETrue:
+					isMaxOrMin = (iFastData.vertexList[tempEdgePtr->upperVertex].iY < iCurrentScanLine);
+					break;
+				}
+
+			if (isMaxOrMin)
+ 				// the vertex-run is a maximum or a minimum
+				{
+				if (aIsLowerVertex)
+					{
+					*iFastData.activeEdgeList[origActiveEdge].scanLineIntersectionPtr=scanLineIntersection;
+					iFastData.activeEdgeList[origActiveEdge].scanLineIntersectionPtr->activeEdgePtr=&iFastData.activeEdgeList[origActiveEdge];
+					}
+				else
+					{
+					// add an intersection
+					iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections]=scanLineIntersection;
+					iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections].activeEdgePtr=&iFastData.activeEdgeList[origActiveEdge];
+					iFastData.activeEdgeList[origActiveEdge].scanLineIntersectionPtr=&iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections];
+					++iFastData.numScanLineIntersections;
+					}
+				break;
+				}
+
+			// the active-edge is horizontal, or the vertex-run is not a maximum or a minimum
+
+			++aCurrentActiveEdge;
+			GRAPHICS_ASSERT_DEBUG(aCurrentActiveEdge<iFastData.numActiveEdges, EDirectGdiPanicPolygonFiller);
+
+			// update scanLineIntersection
+			TPoint startPos, endPos;
+			TInt minX, maxX;
+			iFastData.activeEdgeList[aCurrentActiveEdge].lineGenerator.SingleScanline(startPos, endPos);
+			minX=Min(startPos.iX, endPos.iX);
+			maxX=Max(startPos.iX, endPos.iX);
+			if (scanLineIntersection.firstPixel>minX)
+				scanLineIntersection.firstPixel=minX;
+			if (scanLineIntersection.lastPixel<maxX)
+				scanLineIntersection.lastPixel=maxX;
+
+			// exit the loop if the vertex-run is *not* a maximum or a minimum
+			tempEdgePtr=iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr;
+			TBool isNeitherMaxOrMin = EFalse;
+
+			switch(aIsLowerVertex)
+				{
+				case EFalse:
+					isNeitherMaxOrMin = (iFastData.vertexList[tempEdgePtr->upperVertex].iY < iCurrentScanLine);
+					break;
+
+				case ETrue:
+					isNeitherMaxOrMin = (iFastData.vertexList[tempEdgePtr->lowerVertex].iY > iCurrentScanLine);
+					break;
+				}
+
+ 			// exit the loop if the vertex-run is *not* a maximum or a minimum
+			if (isNeitherMaxOrMin)
+				{
+				TInt newActiveEdge;
+				TInt oldActiveEdge;
+				if (aIsLowerVertex)
+					{
+					newActiveEdge=aCurrentActiveEdge;
+					oldActiveEdge=origActiveEdge;
+					}
+				else
+					{
+					newActiveEdge=origActiveEdge;
+					oldActiveEdge=aCurrentActiveEdge;
+					}
+				iFastData.activeEdgeList[newActiveEdge].scanLineIntersectionPtr=iFastData.activeEdgeList[oldActiveEdge].scanLineIntersectionPtr;
+				iFastData.activeEdgeList[oldActiveEdge].scanLineIntersectionPtr=NULL;
+				*iFastData.activeEdgeList[newActiveEdge].scanLineIntersectionPtr=scanLineIntersection;
+				iFastData.activeEdgeList[newActiveEdge].scanLineIntersectionPtr->activeEdgePtr=&iFastData.activeEdgeList[newActiveEdge];
+				break;
+				}
+			}
+		}
+	else
+		// it is the first vertex of active-edge aCurrentActiveEdge that coincides with the current scan-line
+		{
+#if defined(_DEBUG)
+		// check that the vertex we are at is a maximum or a minimum
+		TInt previousNotLevelVertex;
+		TInt SFastEdge::*vertex=(aIsLowerVertex)? &SFastEdge::lowerVertex: &SFastEdge::upperVertex;
+		for (previousNotLevelVertex=iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->*vertex;
+								iFastData.vertexList[iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->*vertex].iY==iFastData.vertexList[previousNotLevelVertex].iY;
+								previousNotLevelVertex=(previousNotLevelVertex+iNumVertexes-1)%iNumVertexes)
+			;
+		TInt nextNotLevelVertex=(iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->*vertex+1)%iNumVertexes;
+		GRAPHICS_ASSERT_DEBUG((iFastData.vertexList[iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->*vertex].iY>iFastData.vertexList[previousNotLevelVertex].iY)==
+					   (iFastData.vertexList[iFastData.activeEdgeList[aCurrentActiveEdge].edgePtr->*vertex].iY>iFastData.vertexList[nextNotLevelVertex].iY),
+																						EDirectGdiPanicPolygonFiller);
+#endif
+
+		if (aIsLowerVertex)
+			SetFastIntersection(iFastData.activeEdgeList[aCurrentActiveEdge],*iFastData.activeEdgeList[aCurrentActiveEdge].scanLineIntersectionPtr);
+		else
+			{
+			// add an intersection
+			SetFastIntersection(iFastData.activeEdgeList[aCurrentActiveEdge], iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections]);
+			iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections].activeEdgePtr=&iFastData.activeEdgeList[aCurrentActiveEdge];
+			iFastData.activeEdgeList[aCurrentActiveEdge].scanLineIntersectionPtr=&iFastData.scanLineIntersectionList[iFastData.numScanLineIntersections];
+			++iFastData.numScanLineIntersections;
+			}
+		}
+	}
+
+/**
+Calculates the extent of the intersection for the current active edge.
+
+@param aActiveEdge The current active edge.
+@param aScanLineIntersection On return, contains the intersection data.
+*/
+void CSwDirectGdiPolygonFiller::SetFastIntersection(SFastActiveEdge& aActiveEdge, SFastScanLineIntersection& aScanLineIntersection)
+	{
+	GRAPHICS_ASSERT_DEBUG(iUseFastAlgorithm, EDirectGdiPanicPolygonFiller);
+
+	TPoint startPos, endPos;
+
+	aActiveEdge.lineGenerator.SingleScanline(startPos, endPos);
+	aScanLineIntersection.firstPixel=Min(startPos.iX, endPos.iX);
+	aScanLineIntersection.lastPixel=Max(startPos.iX, endPos.iX);
+	}
+
+/**
+Builds up drawing meta-data in the case where a scanline intersects the active edge at a vertex using
+slow algorithms.
+
+@param aScanLineIntersection Reference to the current intersection data.
+@param aVertexStartingCurrentEdge Current vertex.
+@param aIsLowerVertex If the vertex is the lower vertex ETrue otherwise EFalse.
+@see GetNextPixelRunOnSpecifiedScanLine()
+*/
+void CSwDirectGdiPolygonFiller::SlowHandleVertexIntersection(SSlowScanLineIntersection& aScanLineIntersection, 
+												  TInt& aVertexStartingCurrentEdge,
+												  TBool aIsLowerVertex)
+	{
+	if (Point((aVertexStartingCurrentEdge+1)%iNumVertexes).iY==iCurrentScanLine)
+		// it is the second vertex of the edge starting at vertex aVertexStartingCurrentEdge%iNumVertexes
+		// that coincides with the current scan-line
+		{
+		// walk through subsequent adjacent horizontal active-edges
+		for (; ; )
+			{
+			TPoint nextVertexButOne=Point((aVertexStartingCurrentEdge+2)%iNumVertexes);
+			TBool isMaxOrMin = EFalse;
+
+			switch(aIsLowerVertex)
+				{
+				case EFalse:
+					isMaxOrMin = (nextVertexButOne.iY > iCurrentScanLine);
+					break;
+
+				case ETrue:
+					isMaxOrMin = (nextVertexButOne.iY < iCurrentScanLine);
+					break;
+				}
+
+			// exit the loop if the vertex-run *is* a maximum or a minimum
+			if (isMaxOrMin)
+				{
+				break;
+				}
+
+			// the edge starting at vertex aVertexStartingCurrentEdge%iNumVertexes is horizontal, or the vertex-run is not a
+			// maximum or a minimum
+
+			++aVertexStartingCurrentEdge;
+			GRAPHICS_ASSERT_DEBUG(aVertexStartingCurrentEdge%iNumVertexes!=iFirstVertex, EDirectGdiPanicPolygonFiller);
+
+			// step through the line-generator until the current scan-line is reached
+			TPoint upper=Point(aVertexStartingCurrentEdge%iNumVertexes);
+			TPoint lower=nextVertexButOne;
+			if (upper.iY>lower.iY)
+				{
+				TPoint temp=upper;
+				upper=lower;
+				lower=temp;
+				}
+
+			TPoint startPos, endPos;
+			if (upper.iY!=lower.iY)
+				JumpToCurrentScanLine(iSlowData.lineGenerator, upper, lower, startPos, endPos);
+			else
+				{
+				// N.B. which is set to which doesn't matter, as long as startPos is set to either upper or lower, and endPos is set to the other
+				startPos=upper;
+				endPos=lower;
+				}
+
+			// expand the intersection, if necessary
+			TInt minX=Min(startPos.iX, endPos.iX);
+			TInt maxX=Max(startPos.iX, endPos.iX);
+			if (aScanLineIntersection.firstPixel>minX)
+				aScanLineIntersection.firstPixel=minX;
+			if (aScanLineIntersection.lastPixel<maxX)
+				aScanLineIntersection.lastPixel=maxX;
+
+			TBool isNeitherMaxOrMin = EFalse;
+
+			switch(aIsLowerVertex)
+				{
+				case EFalse:
+					isNeitherMaxOrMin = (nextVertexButOne.iY < iCurrentScanLine);
+					break;
+
+				case ETrue:
+					isNeitherMaxOrMin = (nextVertexButOne.iY > iCurrentScanLine);
+					break;
+				}
+							  
+			// exit the loop if the vertex-run is *not* a maximum or a minimum					   
+			if (isNeitherMaxOrMin)
+				{
+				if (aIsLowerVertex)
+					{
+					aScanLineIntersection.firstVertexOfEdge=aVertexStartingCurrentEdge%iNumVertexes;
+					}
+				break;
+				}
+			}
+		}
+	else
+		// it is the first vertex of the edge starting at vertex aVertexStartingCurrentEdge%iNumVertexes
+		// that coincides with the current scan-line
+		{
+#if defined(_DEBUG)
+		// check that the vertex we are at is a maximum or a minimum
+		TInt previousNotLevelVertex;
+		for (previousNotLevelVertex=aVertexStartingCurrentEdge%iNumVertexes;
+														Point(aVertexStartingCurrentEdge%iNumVertexes).iY==
+														Point(previousNotLevelVertex).iY;
+														previousNotLevelVertex=(previousNotLevelVertex+iNumVertexes-1)%iNumVertexes)
+			;
+		TInt nextNotLevelVertex=(aVertexStartingCurrentEdge+1)%iNumVertexes;
+		TInt previousY=Point(previousNotLevelVertex).iY;
+		TInt currentY=Point(aVertexStartingCurrentEdge%iNumVertexes).iY;
+		TInt nextY=Point(nextNotLevelVertex).iY;
+		GRAPHICS_ASSERT_DEBUG((currentY>previousY) == (currentY>nextY), EDirectGdiPanicPolygonFiller);
+#endif
+		}
+	}
+
+/**
+For a given line between two given endpoints, calculate the right and leftmost pixels of the line segment 
+that fall on the current scanline.
+
+@param aLineGenerator Reference to class used to calculate the pixels on the line. 
+@param aUpper The upper endpoint of the line.
+@param aLower The lower endpoint of the line.
+@param aStartPos On return, contains the position of the line's leftmost pixel on the current scanline. 
+@param aEndPos On return, contains the position of the line's rightmost pixel on the current scanline.
+*/
+void CSwDirectGdiPolygonFiller::JumpToCurrentScanLine(TLinearDDA& aLineGenerator, 
+										   const TPoint& aUpper, 
+										   const TPoint& aLower,
+										   TPoint& aStartPos, 
+										   TPoint& aEndPos) const
+	{
+	GRAPHICS_ASSERT_DEBUG(aUpper.iY<=aLower.iY, EDirectGdiPanicPolygonFiller);
+	aLineGenerator.Construct(aUpper, aLower);
+	if (aUpper.iY<iCurrentScanLine)
+		{
+		TInt notUsed;
+		aLineGenerator.JumpToYCoord(notUsed, iCurrentScanLine-2);
+		}
+	do
+		aLineGenerator.SingleScanline(aStartPos, aEndPos);
+	while (aStartPos.iY!=iCurrentScanLine);
+	GRAPHICS_ASSERT_DEBUG(aStartPos.iY==iCurrentScanLine, EDirectGdiPanicPolygonFiller);
+	GRAPHICS_ASSERT_DEBUG(aEndPos.iY==iCurrentScanLine, EDirectGdiPanicPolygonFiller);
+	}
+
+/**
+Returns the point data for a given index.
+
+@param aIndex The index.
+@return The point data.
+*/
+const TPoint& CSwDirectGdiPolygonFiller::Point(TInt aIndex)
+	{
+	GRAPHICS_ASSERT_DEBUG(iPointArray,EDirectGdiPanicPolygonFiller);
+	return((*iPointArray)[aIndex]);
+	}
+