// 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 <fntstore.h>

 #include <bitmap.h>

 #include <bitstd.h>

 #include <bitdev.h>

 #include "BITPANIC.H"

 #include <bitdraw.h>

 #include <graphics/fbsrasterizer.h>

 /**

 Draws and fills a rectangle with rounded corners.

 The function provides a concrete implementation of the pure virtual

 function <code>CGraphicsContext::DrawRoundRect()</code>. The function

 behaviour is the same as documented in that class.

 */

 EXPORT_C void CFbsBitGc::DrawRoundRect(const TRect& aRect,const TSize& aSize)

 	{

 	if (CheckDevice(aRect))

 		return;

 	TSize ellsize(aSize);

 	ellsize.iWidth <<= 1;

 	ellsize.iHeight <<= 1;

 	if (ellsize.iWidth < 3 || ellsize.iHeight < 3)

 		{

 		DrawRect(aRect);

 		return;

 		}

 	if (aRect.Width() < ellsize.iWidth && aRect.Height() < ellsize.iHeight)

 		{

 		DrawEllipse(aRect);

 		return;

 		}

 	TRect rcpy(aRect);

 	rcpy.Move(iOrigin);

 	iDevice->TruncateRect(rcpy);

 	ellsize.iWidth = Min(rcpy.Width(),ellsize.iWidth);

 	ellsize.iHeight = Min(rcpy.Height(),ellsize.iHeight);

 	TRect clippedBoundingRect(rcpy);

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

 	if (!clippedBoundingRect.Intersects(iUserClipRect))

 		return;

 	SetupDevice();

 	iDevice->DrawingBegin(&iBrushBitmap);

 	CFbsRasterizer* brushRasterizer = PrepareRasterizerForExtendedBitmap(iBrushBitmap);

 	if (iBrushStyle != ENullBrush)

 		RoundRectFill(rcpy,ellsize);

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

 		RoundRectOutline(rcpy,ellsize);

 	if (brushRasterizer)

 		{

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

 		}

 	iDevice->DrawingEnd(&iBrushBitmap);

 	}

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

 void CFbsBitGc::RoundRectFill(const TRect& aRect,TSize aSize)

 	{

 	TRect rcpy(aRect);

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

 		rcpy.Grow(1,1);

 	AddRect(rcpy);

 	if (rcpy.iBr.iX - rcpy.iTl.iX < aSize.iWidth)

 		aSize.iWidth = rcpy.Width();

 	if (rcpy.iBr.iY - rcpy.iTl.iY < aSize.iHeight)

 		aSize.iHeight = rcpy.Height();

 	TInt xoff = rcpy.Width() - aSize.iWidth;

 	TInt yoff = rcpy.Height() - aSize.iHeight;

 	TPoint tl,tr,bl,br;

 	TInt prevlev = 0;

 	TBool draw = EFalse;

 	const TInt limit = iDefaultRegionPtr->Count();

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

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		if (UserClipRect(iClipRect))

 			continue;

 		if (!iClipRect.Intersects(aRect))

 			continue;

 		draw = ETrue;

 		iClipRect.Intersection(aRect);

 		TEllipse ellipse;

 		ellipse.Construct(TRect(rcpy.iTl,rcpy.iTl + aSize));

 		ellipse.SingleStep(tl,tr,bl,br);

 		prevlev = tl.iY;

 		while (!ellipse.SingleStep(tl,tr,bl,br))

 			{

 			if (tl.iY == prevlev)

 				continue;

 			tl.iX++;

 			tr.iX += xoff - 1;

 			bl.iX++;

 			bl.iY += yoff;

 			br.iX += xoff - 1;

 			br.iY += yoff;

 			ClipFillLine(tl,tr);

 			ClipFillLine(bl,br);

 			prevlev = tl.iY;

 			}

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	if (!draw)

 		return;

 	if (tl.iY >= bl.iY)

 		{

 		tl.iY--;

 		br.iY++;

 		}

 	tl.iX++;

 	tl.iY++;

 	br.iX += xoff;

 	br.iY += yoff;

 	RectFill(TRect(tl,br));

 	}

 void CFbsBitGc::RoundRectOutline(const TRect& aRect,TSize aSize)

 	{

 	TRect rcpy(aRect);

 	const TInt halfpenwidth = (iPenSize.iWidth + 1) >> 1;

 	const TInt halfpenheight = (iPenSize.iWidth + 1) >> 1;

 	rcpy.Grow(halfpenwidth,halfpenheight);

 	AddRect(rcpy);

 	if (aRect.Width() < aSize.iWidth)

 		aSize.iWidth = aRect.Width();

 	if (aRect.Height() < aSize.iHeight)

 		aSize.iHeight = aRect.Height();

 	TPoint tl,tr,bl,br;

 	const TInt xoff = aRect.Width() - aSize.iWidth;

 	const TInt yoff = aRect.Height() - aSize.iHeight;

 	const TInt dotparam = iDotParam;

 	const TInt limit = iDefaultRegionPtr->Count();

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

 		{

 		iClipRect = (*iDefaultRegionPtr)[count];

 		if (!iClipRect.Intersects(rcpy))

 			continue;

 		iClipRect.Intersection(rcpy);

 		if (UserClipRect(iClipRect))

 			continue;

 		iDotParam = Max(iPenSize.iWidth >> 1,iPenSize.iHeight >> 1);

 		TInt column = aRect.iTl.iX + (aSize.iWidth >> 1);

 		TInt lastcolumn = aRect.iTl.iX + xoff + (aSize.iWidth >> 1);

 		for (; column < lastcolumn; column++)

 			{

 			PenDrawClipped(TPoint(column,aRect.iTl.iY));

 			PenDrawClipped(TPoint(column,aRect.iBr.iY - 1));

 			iDotParam += iDotDirection;

 			}

 		TEllipse ellipse;

 		ellipse.Construct(TRect(aRect.iTl,aRect.iTl + aSize));

 		while (!ellipse.SingleStep(tl,tr,bl,br))

 			{

 			tr.iX += xoff;

 			bl.iY += yoff;

 			br.iX += xoff;

 			br.iY += yoff;

 			PenDrawClipped(tl);

 			PenDrawClipped(tr);

 			PenDrawClipped(bl);

 			PenDrawClipped(br);

 			iDotParam += iDotDirection;

 			}

 		if (tl.iY >= bl.iY)

 			{

 			tl.iY--;

 			bl.iY++;

 			}

 		bl.iY += yoff;

 		for (column = tl.iY + 1; column < bl.iY; column++)

 			{

 			PenDrawClipped(TPoint(aRect.iTl.iX,column));

 			PenDrawClipped(TPoint(aRect.iBr.iX - 1,column));

 			iDotParam += iDotDirection;

 			}

 		iDevice->iDrawDevice->UpdateRegion(iClipRect);

 		}

 	iDotParam = dotparam;

 	}