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