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