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

#include <bmalphablend.h>

#include <bitdraw.h>

#include <graphics/fbsrasterizer.h>

#include <graphics/bitmap.inl>

#include <graphics/gdi/gdiinline.inl>

/**

Draws a bitmap.

The function has 3 overloads. The first draws the bitmap given the top

left hand corner, doing a compress/stretch based on its internally

stored size in twips. The second does a compress/stretch to fit a

given rectangle. The third takes a rectangular section of the source

bitmap and does a compress/stretch to fit a given destination

rectangle.The functions provide a concrete implementation of the pure

virtual function <code>CGraphicsContext::DrawBitmap()</code>. The

function behaviour is the same as documented in that class.

*/

EXPORT_C void CFbsBitGc::DrawBitmap(const TPoint& aPos,const CFbsBitmap* aSource)

	{

	if (aSource == NULL || !aSource->Handle())

		return;

	aSource->BeginDataAccess();

	const TSize bitmapTwips = aSource->SizeInTwips();

	if (bitmapTwips.iWidth == 0 || bitmapTwips.iHeight == 0)

		{

		aSource->EndDataAccess(ETrue);

		return;

		}

	TSize scrpixels;

	scrpixels.iWidth = iDevice->HorizontalTwipsToPixels(bitmapTwips.iWidth);

	scrpixels.iHeight = iDevice->VerticalTwipsToPixels(bitmapTwips.iHeight);

	DrawBitmap(TRect(aPos, scrpixels), aSource, TRect(aSource->SizeInPixels()));

	aSource->EndDataAccess(ETrue);

	}

EXPORT_C void CFbsBitGc::DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource)

	{

	if (aSource == NULL || !aSource->Handle())

		return;

	aSource->BeginDataAccess();

	DrawBitmap(aDestRect, aSource, TRect(aSource->SizeInPixels()));

	aSource->EndDataAccess(ETrue);

	}

EXPORT_C void CFbsBitGc::DrawBitmap(const TRect& aDestRect,

									const CFbsBitmap* aSource,

									const TRect& aSourceRect)

	{

	if (CheckDevice(aDestRect) || aSourceRect.IsEmpty() || aSource == NULL || !aSource->Handle())

		return;

	aSource->BeginDataAccess();

	//aSourceRect should be in the bounds of the bitmap

	TSize bitmapSize(aSource->SizeInPixels());

	if ( aSourceRect.iTl.iX < 0

			|| aSourceRect.iTl.iY < 0

			|| aSourceRect.iBr.iX > bitmapSize.iWidth

			|| aSourceRect.iBr.iY > bitmapSize.iHeight)

		{

		aSource->EndDataAccess(ETrue);

		return;

		}

	TRect destRect(aDestRect);

	destRect.Move(iOrigin);

	AddRect(destRect);

	TRect clippedDestRect(destRect);

	if (UserClipRect(clippedDestRect))

		{

		aSource->EndDataAccess(ETrue);

		return;

		}

	CFbsBitGcBitmap* srce = (CFbsBitGcBitmap*)aSource;

	SetupDevice();

	iDevice->DrawingBegin();

	CBitwiseBitmap* bmp = srce->Address();

	BG_ASSERT_DEBUG(bmp,EBitgdiPanicInvalidBitmap);

	CFbsRasterizer* rasterizer = PrepareRasterizerForExtendedBitmap(*aSource, destRect, aSourceRect);

	const TPoint ditherOrigin(iDitherOrigin + aDestRect.iTl);

	const TInt limit = iDefaultRegionPtr->Count();

	CGraphicsAccelerator* ga = GraphicsAccelerator();

	if (ga && iShadowMode==CFbsDrawDevice::ENoShadow && iDrawMode==EDrawModePEN)

		{

		TInt gaOperationResult = KErrUnknown;

		TAcceleratedBitmapSpec bitmapSpec(const_cast<CFbsBitmap*>(aSource));

		iDevice->DrawingEnd();

		if (destRect.Size() == aSourceRect.Size())

			{

			const TPoint offset(aSourceRect.iTl - destRect.iTl);

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

				{

				iClipRect=(*iDefaultRegionPtr)[count];

				if(!iClipRect.Intersects(clippedDestRect))

					continue;

				iClipRect.Intersection(clippedDestRect);

				TRect clippedSrceRect(iClipRect);

				clippedSrceRect.Move(offset);

				gaOperationResult = ga->Operation(TGopBitBlt(iClipRect.iTl,bitmapSpec,clippedSrceRect));

				if (gaOperationResult!=KErrNone)

					break;

				}

			iDevice->iDrawDevice->UpdateRegion(iClipRect);

			}

		else

			{

			RRegion clippedRegion;

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

				{

				TRect clipRect((*iDefaultRegionPtr)[clipIt]);

				clipRect.Intersection(clippedDestRect);

				if (!clipRect.IsEmpty())

					clippedRegion.AddRect(clipRect);

				}

			TRect srcCopy(aSourceRect);	// Needed because TGopScaledBitBlt takes a non-const value

			// const_cast needed because Operation takes a non-const region ptr :(

			gaOperationResult = ga->Operation(TGopScaledBitBlt(destRect,bitmapSpec,srcCopy),clippedRegion.Count(),const_cast<TRect*>(clippedRegion.RectangleList()));

			if (gaOperationResult==KErrNone) 	 

				iDevice->iDrawDevice->Update(clippedRegion);

			clippedRegion.Close();

			}

		if(gaOperationResult == KErrNone)

			goto finish;

		iDevice->DrawingBegin();

		}

//

	{	// to stop error from gccxml build about previous jump to finish skipping initialisation of opaqueSource 

	const TBool opaqueSource = (!IsAlphaChannel(aSource->DisplayMode())) && (iDrawMode == EDrawModePEN);

	if (opaqueSource)

		{

		iDrawMode = EDrawModeWriteAlpha;

		}

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

		{

		iClipRect = (*iDefaultRegionPtr)[count];

		if (!iClipRect.Intersects(clippedDestRect))

			continue;

		iClipRect.Intersection(clippedDestRect);

		DoDrawBitmap(destRect,bmp,aSource->DataAddress(),aSource->DataStride(),aSourceRect,ditherOrigin);

		iDevice->iDrawDevice->UpdateRegion(iClipRect);

		}

	if (opaqueSource)

		{

		iDrawMode = EDrawModePEN;

		}

	}

	iDevice->DrawingEnd();

finish:

	if (rasterizer)

		{

		rasterizer->EndBitmap(aSource->SerialNumber());

		}

	aSource->EndDataAccess(ETrue);

	}

void CFbsBitGc::DoDrawBitmap(const TRect& aDestRect,

							 CBitwiseBitmap* aBitmap,

							 TUint32* aBase,

							 TInt aStride,

							 const TRect& aSrceRect,

							 const TPoint& aDitherOrigin)

	{

	CFbsDrawDevice* drawDevice = iDevice->iDrawDevice;

#ifdef _DEBUG

	TRect deviceDestRect;

	drawDevice->GetDrawRect(deviceDestRect);

#endif

	BG_ASSERT_DEBUG(iClipRect.iTl.iX >= deviceDestRect.iTl.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(iClipRect.iTl.iY >= deviceDestRect.iTl.iY, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(iClipRect.iBr.iX <= deviceDestRect.iBr.iX, EBitgdiPanicOutOfBounds);

	BG_ASSERT_DEBUG(iClipRect.iBr.iY <= deviceDestRect.iBr.iY, EBitgdiPanicOutOfBounds);

	if (aDestRect.Size() == aSrceRect.Size())

		{

		TRect clippedRect(aDestRect);

		clippedRect.Intersection(iClipRect);

		if (!clippedRect.IsEmpty())

			{

			const TPoint destPoint(clippedRect.iTl);

			clippedRect.Move(aSrceRect.iTl - aDestRect.iTl);

			DoBitBlt(destPoint,aBitmap,aBase,aStride,clippedRect);

			}

		return;

		}

	MFastBlend* fastBlend=NULL;

	if (FastBlendInterface(aBitmap,NULL,fastBlend)==KErrNone)

		{

		if (fastBlend->FastBlendBitmapScaled(iClipRect, aDestRect, aSrceRect, aBase, aStride, aBitmap->DisplayMode(), aBitmap->SizeInPixels(), iDrawMode, iShadowMode)== KErrNone)

			{

			return;

			}

		}

	TUint32* scanLineBuffer = drawDevice->ScanLineBuffer();

	const TInt scanLineBytes = drawDevice->ScanLineBytes();

	TPtr8 scanLineDes(REINTERPRET_CAST(TUint8*,scanLineBuffer),scanLineBytes,scanLineBytes);

	// For EColor16MU targets, don't use EColor16MAP when draw mode is EDrawModeWriteAlpha.

	// Format conversion provides no performance gain and WriteLine expects EColor16MU 

	// in this case.

	const TDisplayMode dispMode = drawDevice->DisplayMode() == EColor16MU && iDrawMode == EDrawModeWriteAlpha ? EColor16MU : drawDevice->ScanLineDisplayMode();

	TLinearDDA xLine;

	TInt bitmapXStart = 0;

	xLine.Construct(TPoint(aSrceRect.iTl.iX,aDestRect.iTl.iX),

					TPoint(aSrceRect.iBr.iX,aDestRect.iBr.iX),TLinearDDA::ELeft);

	xLine.JumpToYCoord(bitmapXStart,iClipRect.iTl.iX);

	TLinearDDA yLine;

	TPoint yCoord(aSrceRect.iTl.iY,aDestRect.iTl.iY);

	yLine.Construct(yCoord,TPoint(aSrceRect.iBr.iY,aDestRect.iBr.iY),TLinearDDA::ELeft);

	TInt dummy;

	yLine.JumpToYCoord2(dummy,iClipRect.iTl.iY);

	yCoord.SetXY(dummy,iClipRect.iTl.iY);

	TBool finished = EFalse;

	TPoint ditherOrigin(aDitherOrigin + iClipRect.iTl);

	const TInt srceWidth = aSrceRect.Width();

	const TInt destWidth = aDestRect.Width();

	const TInt clipWidth = iClipRect.Width();

	const TInt clipStrch = iClipRect.iTl.iX - aDestRect.iTl.iX;

	TLineScanningPosition lineScanPos(aBase);

	while (yCoord.iY < iClipRect.iBr.iY && !finished)

		{

		aBitmap->StretchScanLine(scanLineDes,TPoint(bitmapXStart,yCoord.iX),

								 clipStrch,clipWidth,destWidth,aSrceRect.iTl.iX,

								 srceWidth,ditherOrigin,dispMode,aBase,lineScanPos);

		if (yCoord.iY==iClipRect.iTl.iY)

			aBitmap->SetCompressionBookmark(lineScanPos, aBase,NULL);

		drawDevice->WriteLine(iClipRect.iTl.iX,yCoord.iY,clipWidth, scanLineBuffer,iDrawMode);

		finished = yLine.NextStep(yCoord);

		ditherOrigin.iY++;

		}

	}

/** The method draws a specified rectangle from a bitmap and

its mask into another rectangle and does a compress/stretch

to fit a given destination rectangle.

@note When using this function with a 256 Mask bitmap, it blends.

Otherwise (e.g. with a 4bpp mask), this function masks rather than blends.

If a user wants to blend the source into the destination they should use

CFbsBitGc::AlphaBlendBitmaps() instead.

@publishedAll

@released

@param aDestRect The rectangle within which the masked bitmap is to be drawn.

@param aBitmap A pointer to the source bitmap.

@param aSourceRect The rectangle in the source bitmap that is copied to the

destination rectangle.

@param aMaskBitmap A pointer to the mask bitmap.

@param aInvertMask If false, a source pixel that is masked by a black pixel

is not transferred to the destination rectangle. If true, then a source pixel

that is masked by a white pixel is not transferred to the destination rectangle.

@pre aBitmap != NULL

@pre aBitmap->Handle() != 0

@pre aMaskBitmap != NULL

@pre aMaskBitmap->Handle() != 0

@pre !aSourceRect.IsEmpty()

@pre aSourceRect should be in the bounds of the bitmap

*/

EXPORT_C void CFbsBitGc::DrawBitmapMasked(const TRect& aDestRect,

						 const CFbsBitmap* aBitmap,

						 const TRect& aSourceRect,

						 const CFbsBitmap* aMaskBitmap,

						 TBool aInvertMask)

	{

	if (aBitmap == NULL || !aBitmap->Handle() || aMaskBitmap == NULL ||

		!aMaskBitmap->Handle() || aSourceRect.IsEmpty() || CheckDevice(aDestRect))

		{

		return;

		}

	aBitmap->BeginDataAccess();

	aMaskBitmap->BeginDataAccess();

	//aSourceRect should be in the bounds of the bitmap

	TSize bitmapSize(aBitmap->SizeInPixels());

	if ( aSourceRect.iTl.iX < 0

			|| aSourceRect.iTl.iY < 0

			|| aSourceRect.iBr.iX > bitmapSize.iWidth

			|| aSourceRect.iBr.iY > bitmapSize.iHeight)

		{

		aBitmap->EndDataAccess(ETrue);

		aMaskBitmap->EndDataAccess(ETrue);

		return;

		}   		

	TRect destRect(aDestRect);

	destRect.Move(iOrigin);

	AddRect(destRect);

	TRect clippedDestRect(destRect);

	if (UserClipRect(clippedDestRect))

		{

		aBitmap->EndDataAccess(ETrue);

		aMaskBitmap->EndDataAccess(ETrue);

		return;

		}

	SetupDevice();

	const TBool opaqueSource = (!IsAlphaChannel(aBitmap->DisplayMode())) && (iDrawMode == EDrawModePEN);

	iDevice->DrawingBegin();

	CBitwiseBitmap* srcebmp = ((CFbsBitGcBitmap*)aBitmap)->Address();

	CBitwiseBitmap* maskbmp = ((CFbsBitGcBitmap*)aMaskBitmap)->Address();

	BG_ASSERT_DEBUG(srcebmp,EBitgdiPanicInvalidBitmap);

	BG_ASSERT_DEBUG(maskbmp,EBitgdiPanicInvalidBitmap);

	CFbsRasterizer* rasterizer = PrepareRasterizerForExtendedBitmap(*aBitmap, destRect, aSourceRect);

	CFbsRasterizer* maskRasterizer = NULL;

	if (srcebmp != maskbmp)

		{

		if (aMaskBitmap->SizeInPixels().iWidth >= aBitmap->SizeInPixels().iWidth

			&& aMaskBitmap->SizeInPixels().iHeight >= aBitmap->SizeInPixels().iHeight)

			{

			// Mask is not tiled. Pass same region of interest as source bitmap to rasterizer.

			maskRasterizer = PrepareRasterizerForExtendedBitmap(*aMaskBitmap, destRect, aSourceRect);

			}

		else

			{

			// Mask is tiled. Do not pass any region of interest to rasterizer.

			maskRasterizer = PrepareRasterizerForExtendedBitmap(*aMaskBitmap);

			}

		}

	const TPoint ditherOrigin(iDitherOrigin + aDestRect.iTl);

	const TInt limit = iDefaultRegionPtr->Count();

//

	CGraphicsAccelerator* ga = GraphicsAccelerator();

	if (ga && iShadowMode==CFbsDrawDevice::ENoShadow && (aMaskBitmap->DisplayMode()!=EGray2 || !aInvertMask) && iDrawMode==EDrawModePEN)

		{

		TInt gaOperationResult = KErrUnknown;

		TAcceleratedBitmapSpec bitmapSpec(const_cast<CFbsBitmap*>(aBitmap));

		iDevice->DrawingEnd();

		TAcceleratedBitmapSpec maskSpec(const_cast<CFbsBitmap*>(aMaskBitmap));

		const TPoint offset(aSourceRect.iTl - destRect.iTl);

		if (destRect.Size() == aSourceRect.Size())

			{

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

				{

				iClipRect=(*iDefaultRegionPtr)[count];

				if(!iClipRect.Intersects(clippedDestRect))

					continue;

				iClipRect.Intersection(clippedDestRect);

				TRect clippedSrceRect(iClipRect);

				clippedSrceRect.Move(offset);

				gaOperationResult = ga->Operation(TGopBitBltMasked(iClipRect.iTl,bitmapSpec,clippedSrceRect,maskSpec)); 	 

				if (gaOperationResult!=KErrNone) 	 

					break; 	 

				iDevice->iDrawDevice->UpdateRegion(iClipRect);

				}

			}

		else

			{

			RRegion clippedRegion;

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

				{

				TRect clipRect((*iDefaultRegionPtr)[clipIt]);

				clipRect.Intersection(clippedDestRect);

				if (!clipRect.IsEmpty())

					clippedRegion.AddRect(clipRect);

				}

			TRect srcCopy(aSourceRect);	// Needed because TGopScaledBitBltMasked takes a non-const value

			// const_cast needed because Operation takes a non-const region ptr :(

			gaOperationResult = ga->Operation(TGopScaledBitBltMasked(destRect,bitmapSpec,srcCopy,maskSpec),clippedRegion.Count(),const_cast<TRect*>(clippedRegion.RectangleList()));

			if (gaOperationResult==KErrNone) 	 

				iDevice->iDrawDevice->Update(clippedRegion);

			clippedRegion.Close();

			} 	 

		if (gaOperationResult==KErrNone) 	 

			goto finish;

		iDevice->DrawingBegin(); 	 

		}

//

	if (opaqueSource)

		iDrawMode = EDrawModeWriteAlpha;

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

		{

		iClipRect = (*iDefaultRegionPtr)[count];

		if (!iClipRect.Intersects(clippedDestRect))

			continue;

		iClipRect.Intersection(clippedDestRect);

		DoDrawBitmapMasked(destRect,

					   srcebmp,

					   aBitmap->DataAddress(),

					   aSourceRect,

					   maskbmp,

					   aMaskBitmap->DataAddress(),

					   aInvertMask, ditherOrigin);

		iDevice->iDrawDevice->UpdateRegion(iClipRect);

		}

	if (opaqueSource)

		iDrawMode = EDrawModePEN;

	iDevice->DrawingEnd();

finish:

	if (rasterizer)

		{

		rasterizer->EndBitmap(aBitmap->SerialNumber());

		}

	if (maskRasterizer)

		{

		maskRasterizer->EndBitmap(aMaskBitmap->SerialNumber());

		}

	aBitmap->EndDataAccess(ETrue);

	aMaskBitmap->EndDataAccess(ETrue);

	}

/** The method draws a specified rectangle from a bitmap and

its mask into another rectangle and does a compress/stretch

to fit a given destination rectangle.

This is an overload, which takes CWsBitmap* as argument, which

in turn calls the other overload.

Note: A pointer to CWsBitmap must have the same pointer value as a pointer

to the associated CFbsBitmap, otherwise code in BitGdi component will be

Broken.

@note When using this function with a 256 Mask bitmap, it blends.

Otherwise (e.g. with a 4bpp mask), this function masks rather than blends.

If a user wants to blend the source into the destination they should use

CFbsBitGc::AlphaBlendBitmaps() instead.

@publishedAll

@released

@param aDestRect The rectangle within which the masked bitmap is to be drawn.

@param aBitmap A pointer to the source bitmap.

@param aSourceRect The rectangle in the source bitmap that is copied to the

destination rectangle.

@param aMaskBitmap A pointer to the mask bitmap.

@param aInvertMask If false, a source pixel that is masked by a black pixel

is not transferred to the destination rectangle. If true, then a source pixel

that is masked by a white pixel is not transferred to the destination rectangle.

@pre aBitmap != NULL

@pre aBitmap->Handle() != 0

@pre aMaskBitmap != NULL

@pre aMaskBitmap->Handle() != 0

@pre !aSourceRect.IsEmpty()

*/

EXPORT_C void CFbsBitGc::DrawBitmapMasked(const TRect& aDestRect,

						 const CWsBitmap* aBitmap,

						 const TRect& aSourceRect,

						 const CWsBitmap* aMaskBitmap,

						 TBool aInvertMask)

	{

	DrawBitmapMasked(aDestRect,REINTERPRET_CAST(const CFbsBitmap*,aBitmap),aSourceRect,REINTERPRET_CAST(const CFbsBitmap*,aMaskBitmap),aInvertMask);

	}