Fix def files so that the implementation agnostic interface definition has no non-standards defined entry points, and change the eglrefimpl specific implementation to place its private entry points high up in the ordinal order space in the implementation region, not the standards based entrypoints region.
// 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;
}
}
}