// Copyright (c) 2007-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 "swdirectgdiengine.h"

#include "swdirectgdidriverimpl.h"

#include "directgdiadapter.h"

#include <bitdrawinterfaceid.h>

#include <bmalphablend.h>

#include <graphics/bitmap.inl>

#include <graphics/gdi/gdiinline.inl>

/** 

@see MDirectGdiEngine::BitBlt()

@panic DGDIAdapter 7, aBitmap is invalid (debug only). 

*/

void CSwDirectGdiEngine::BitBlt(const TPoint& aDestPos, 

								const CFbsBitmap& aBitmap,	

								const TRect& aSrceRect)

	{

	if (aBitmap.ExtendedBitmapType() != KNullUid)

		{

		iDriver->SetError(KErrNotSupported); // Not supported for extended bitmaps

		return;

		}

	TRect srceRect(aSrceRect);

	const TPoint destPoint(aDestPos + iOrigin + srceRect.iTl - aSrceRect.iTl);

	const TPoint offset(srceRect.iTl - destPoint);

	TRect targetRect(destPoint,srceRect.Size());

	aBitmap.BeginDataAccess();

	CBitwiseBitmap* srce = static_cast<const CSwDirectGdiBitmap&>(aBitmap).Address();

	GRAPHICS_ASSERT_DEBUG(srce,EDirectGdiPanicInvalidBitmap);

	const TInt limit = iDefaultRegionPtr->Count();		

	TBool opaqueSource = (!IsAlphaChannel(aBitmap.DisplayMode())) && (iDrawMode == DirectGdi::EDrawModePEN);	

	TRect clipRect;

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

		{

		clipRect = (*iDefaultRegionPtr)[count];

		if(!clipRect.Intersects(targetRect))

			{

			continue;

			}

		clipRect.Intersection(targetRect);

		TRect clippedSrceRect(clipRect);

		clippedSrceRect.Move(offset);

		if (opaqueSource)

			{

			iDrawMode = DirectGdi::EDrawModeWriteAlpha; // write rather than blend.

			}		

		DoBitBlt(clipRect.iTl, srce, aBitmap.DataAddress(), aBitmap.DataStride(), clippedSrceRect);

		if (opaqueSource)

			{

			iDrawMode = DirectGdi::EDrawModePEN; // set it back to how it was.

			}

		iDrawDevice->UpdateRegion(clipRect);

		}

	aBitmap.EndDataAccess(ETrue);	

	}

/**

@see MDirectGdiEngine::BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, TBool)

@panic DGDIAdapter 7, if either aMaskBitmap or aBitmap are invalid (debug only).

*/

void CSwDirectGdiEngine::BitBltMasked(const TPoint& aDestPos,

			  const CFbsBitmap& aBitmap,

			  const TRect& aSrcRect,

			  const CFbsBitmap& aMaskBitmap,

			  TBool aInvertMask)

	{

	if ((aBitmap.ExtendedBitmapType() != KNullUid) || (aMaskBitmap.ExtendedBitmapType() != KNullUid))

		{

		iDriver->SetError(KErrNotSupported); // Not supported for extended bitmaps

		return;

		}

	TRect localSrcRect(aSrcRect);

	const TPoint destPoint(aDestPos + iOrigin + localSrcRect.iTl - aSrcRect.iTl);

	const TRect destRect(destPoint, localSrcRect.Size());

	const TPoint offset(localSrcRect.iTl - destPoint);

	TRect targetRect(destRect);

	aBitmap.BeginDataAccess();

	aMaskBitmap.BeginDataAccess();

	CBitwiseBitmap* srcebmp = static_cast<const CSwDirectGdiBitmap&>(aBitmap).Address();

	CBitwiseBitmap* maskbmp = static_cast<const CSwDirectGdiBitmap&>(aMaskBitmap).Address();		

	GRAPHICS_ASSERT_DEBUG(srcebmp,EDirectGdiPanicInvalidBitmap);

	GRAPHICS_ASSERT_DEBUG(maskbmp,EDirectGdiPanicInvalidBitmap);

	const TDisplayMode maskMode = maskbmp->DisplayMode();

	const TInt limit = iDefaultRegionPtr->Count();

	TBool opaqueSource = (!IsAlphaChannel(aBitmap.DisplayMode())) && (iDrawMode == DirectGdi::EDrawModePEN);

	TRect clipRect;

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

		{

		clipRect = (*iDefaultRegionPtr)[count];

		if (!clipRect.Intersects(targetRect))

			{

			continue;

			}

		clipRect.Intersection(targetRect);

		TRect clippedSrceRect(clipRect);

		clippedSrceRect.Move(offset);

		if (opaqueSource)

			{

			iDrawMode = DirectGdi::EDrawModeWriteAlpha; // ie write rather than blend

			}

		DoBitBltMasked(clipRect.iTl, srcebmp, aBitmap.DataAddress(), clippedSrceRect, maskbmp, 

				aMaskBitmap.DataAddress(), aInvertMask);

		if (opaqueSource)

			{

			iDrawMode = DirectGdi::EDrawModePEN; // set to default

			}

		iDrawDevice->UpdateRegion(clipRect);

		}

	aBitmap.EndDataAccess(ETrue);

	aMaskBitmap.EndDataAccess(ETrue);	

	}

/**

@see MDirectGdiEngine::BitBltMasked(const TPoint&, const CFbsBitmap&, const TRect&, const CFbsBitmap&, const TPoint&)

@panic DGDIAdapter 7, if either aBitmap or aMaskBitmap are invalid.

@panic DGDIAdapter 1022, if the top-left corner of aSrcRect is out of bounds (debug only).

*/

void CSwDirectGdiEngine::BitBltMasked(const TPoint& aDestPt,

		const CFbsBitmap& aBitmap, const TRect& aSrcRect,

		const CFbsBitmap& aMaskBitmap, const TPoint& aAlphaPt)

	{

	if ((aBitmap.ExtendedBitmapType() != KNullUid) || (aMaskBitmap.ExtendedBitmapType() != KNullUid))

		{

		iDriver->SetError(KErrNotSupported); // Not supported for extended bitmaps

		return;

		}

	TRect srcRect(aSrcRect);

	//Calculate the destination rect

	TPoint destPt(aDestPt + iOrigin);

	TRect destRect(destPt, srcRect.Size());

	TPoint offset(srcRect.iTl - destPt);

	TRect targetRect(destRect);

	aBitmap.BeginDataAccess();

	aMaskBitmap.BeginDataAccess();

	CBitwiseBitmap* srcBmp = static_cast<const CSwDirectGdiBitmap&>(aBitmap).Address();

	CBitwiseBitmap* alphaBmp = static_cast<const CSwDirectGdiBitmap&>(aMaskBitmap).Address();

	GRAPHICS_ASSERT_DEBUG(srcBmp, EDirectGdiPanicInvalidBitmap);

	GRAPHICS_ASSERT_DEBUG(alphaBmp, EDirectGdiPanicInvalidBitmap);

	TUint32* srcDataAddr = aBitmap.DataAddress();

	TUint32* alphaDataAddr = aMaskBitmap.DataAddress();

	//For each region - find the clipping rect and draw

	TInt limit = iDefaultRegionPtr->Count ();

	TRect clipRect;

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

		{

		clipRect=(*iDefaultRegionPtr)[count];

		if ( !clipRect.Intersects(targetRect))

			{

			continue;

			}

		//targetRect was constructed from destRect. destRect was constructed from srcRect.

		clipRect.Intersection (targetRect);

		TRect clippedSrcRect(clipRect);

		clippedSrcRect.Move(offset);//clippedSrcRect - maps to a part of srcRect now.

		TPoint shift(clippedSrcRect.iTl - srcRect.iTl);

		GRAPHICS_ASSERT_DEBUG(shift.iX >= 0, EDirectGdiPanicNegativeShift);

		GRAPHICS_ASSERT_DEBUG(shift.iY >= 0, EDirectGdiPanicNegativeShift);

		DoBitBltAlpha (clipRect.iTl, srcBmp, srcDataAddr, clippedSrcRect,

				alphaBmp, alphaDataAddr, aAlphaPt + shift, EFalse);

		iDrawDevice->UpdateRegion (clipRect);

		}

	aBitmap.EndDataAccess(ETrue);

	aMaskBitmap.EndDataAccess(ETrue);

	return;

	}			

/** 

Calculates the position into the scanline for the given x coordinate.

@param aX The given x-coordinate.

@param aDisplayMode The applied display mode.

@return The memory offset, or 0 if the mode is not supported.

@panic DGDIAdapter 1009, if aDisplayMode is not supported (debug only).

*/

TUint CSwDirectGdiEngine::MemoryOffsetForPixelPitch(TUint aX, TDisplayMode aDisplayMode) const

	{	

	switch (aDisplayMode)

		{

		case EColor16MU:

		case EColor16MAP:

			return aX << 2;

		case EColor64K:

			return aX << 1;

		default:

			GRAPHICS_PANIC_DEBUG(EDirectGdiPanicInvalidDisplayMode);

		}

	return 0;

	}

TUint32* CSwDirectGdiEngine::GetScanLineOffsetPtr(CBitwiseBitmap* aSrce, TUint32*& aSlptr, 

		TInt aLength, TPoint aPixel, TUint32* aBase, 

		TLineScanningPosition& aLineScanningPosition, TUint aXOffset)

	{

	aSrce->GetScanLinePtr(aSlptr, aLength, aPixel, aBase, aLineScanningPosition);

	return (TUint32*)((TUint8*)aSlptr + aXOffset);

	}

/**

Performs the actual bitblt to the device.

This function may also be called by DrawBitmap(), and DrawRect() when using a patterned brush, 

so any changes to this function may impact on them also.

@pre aSrce A bitmap with non-zero dimensions. aSrceRect has been clipped against the target.

@param aDest The target position on the device which will contain the top left 

             corner of the source bitmap.

@param aSrce The bitmap object that contains the pixels to draw.

@param aBase The address of the bitmap pixels.

@param aStride The length in bytes between scanlines in memory.

@param aSrceRect The area of the bitmap to draw from.

@panic DGDIAdapter 1013, if aDest is fully outside of the bounds of the target, or aSrceRect.iTl is not

       within the drawing area (debug only).

*/

void CSwDirectGdiEngine::DoBitBlt(const TPoint& aDest,

		 CBitwiseBitmap* aSrce,

		 TUint32* aBase,

		 TInt aStride,

		 const TRect& aSrceRect)

	{

	// Does multiple bitmap widths for painting rects only

	const TInt width = aSrceRect.Width ();

#ifdef _DEBUG

	TRect deviceDestRect;

	iDrawDevice->GetDrawRect(deviceDestRect);

	GRAPHICS_ASSERT_DEBUG(aDest.iX >= deviceDestRect.iTl.iX, EDirectGdiPanicOutOfBounds);

	GRAPHICS_ASSERT_DEBUG(aDest.iY >= deviceDestRect.iTl.iY, EDirectGdiPanicOutOfBounds);

	GRAPHICS_ASSERT_DEBUG((aDest.iX + aSrceRect.Width()) <= deviceDestRect.iBr.iX, EDirectGdiPanicOutOfBounds);

	GRAPHICS_ASSERT_DEBUG((aDest.iY + aSrceRect.Height()) <= deviceDestRect.iBr.iY, EDirectGdiPanicOutOfBounds);

	GRAPHICS_ASSERT_DEBUG(aDest.iX >= 0 && aDest.iY >= 0, EDirectGdiPanicOutOfBounds);

	GRAPHICS_ASSERT_DEBUG(aSrceRect.iTl.iX >= 0 && aSrceRect.iTl.iY >= 0, EDirectGdiPanicOutOfBounds);

#endif

	TSize srcSize = aSrce->SizeInPixels ();

	const TPoint KZeroPoint(0,0);

	TAny* interface = NULL;

	if (iDrawMode == DirectGdi::EDrawModeWriteAlpha &&

			aSrceRect.iBr.iX <= srcSize.iWidth && 

			aSrceRect.iBr.iY <= srcSize.iHeight &&

			!aSrce->IsCompressed() && 

			aSrce->DisplayMode() == iDrawDevice->DisplayMode() && 

			iDrawDevice->GetInterface(KFastBlit2InterfaceID, interface) == KErrNone)

		{

		// Conditions in CFbsBitGc allow for optimised blitting.

		// The draw device supports the optimised blitting function.

		// Operation may fail regardless due to unacceptable conditions in the draw device.

		MFastBlit2* fastBlit = reinterpret_cast<MFastBlit2*>(interface);

		if (fastBlit && (fastBlit->WriteBitmapBlock(aDest, aBase, aStride, srcSize, aSrceRect) == KErrNone))			

			{

			return;

			}			

		}

	MFastBlend* fastBlend=NULL;

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

		{

		if (fastBlend->FastBlendBitmap(aDest, aBase, aStride, srcSize, aSrceRect, aSrce->DisplayMode(), GcDrawMode(iDrawMode), CFbsDrawDevice::ENoShadow)== KErrNone)

			{

			return;

			}

		}

	const TInt scanLineBytes = iDrawDevice->ScanLineBytes();

	TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();

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

	const TDisplayMode dispMode = ScanLineBufferDisplayMode(iDrawDevice);

	const TBool useScanLinePtr = (dispMode == aSrce->DisplayMode()) && 

		(TDisplayModeUtils::NumDisplayModeBitsPerPixel(dispMode) >= 8);

	TUint32* slptr = NULL;

	TUint offset = 0;

	TUint32* lastScanLine = NULL;

	if (useScanLinePtr)

		{

		lastScanLine = aSrce->ScanLineAddress(aBase, aSrceRect.iBr.iY-1);

		}

	TInt srceWidth = srcSize.iWidth;

	TInt partlinestart = aSrceRect.iTl.iX % srceWidth;

	if (partlinestart < 0)

		{

		partlinestart += srceWidth;

		}

	const TInt partlinelength = Min(srceWidth - partlinestart, width);

	TInt destX = aDest.iX;

	const TInt destXlimit = destX+width;

	const CGraphicsContext::TDrawMode drawMode = GcDrawMode(iDrawMode);

	// first part line

	if (partlinestart > 0 && partlinelength > 0)

		{

		TPoint srcecoord1(partlinestart, aSrceRect.iTl.iY);

		TInt desty = aDest.iY;

		TLineScanningPosition lineScanPos(aBase);

		if (useScanLinePtr)

			{

			offset = MemoryOffsetForPixelPitch(partlinestart, dispMode);

			if (aSrce->IsCompressed ())

				{

				while (srcecoord1.iY < aSrceRect.iBr.iY)

					{

					scanLineBuffer = GetScanLineOffsetPtr (aSrce, slptr,

							partlinelength, srcecoord1, aBase, lineScanPos, offset);

					if (srcecoord1.iY == aSrceRect.iTl.iY)

						{

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

						}

					iDrawDevice->WriteLine(aDest.iX, desty, partlinelength,

							scanLineBuffer, drawMode);

					srcecoord1.iY++;

					desty++;				

					}

				}

			else

				{

				while (srcecoord1.iY < aSrceRect.iBr.iY)

					{

					scanLineBuffer = GetScanLineOffsetPtr (aSrce, slptr,

							partlinelength, srcecoord1, aBase, lineScanPos,

							offset);

					do

						{

						iDrawDevice->WriteLine (aDest.iX, desty,

								partlinelength, scanLineBuffer, drawMode);

						scanLineBuffer = (TUint32*)((TUint8*)scanLineBuffer + aStride);

						srcecoord1.iY++;

						desty++;

						}

					while ((srcecoord1.iY < aSrceRect.iBr.iY) && (scanLineBuffer < lastScanLine)) ;

					}

				}

			}

		else

			{

			for ( ; srcecoord1.iY < aSrceRect.iBr.iY; srcecoord1.iY++, desty++)

				{

				aSrce->GetScanLine (scanLineDes, srcecoord1, partlinelength,

						EFalse, KZeroPoint, dispMode, aBase, lineScanPos);

				if ( srcecoord1.iY==aSrceRect.iTl.iY)

					{

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

					}

				iDrawDevice->WriteLine (aDest.iX, desty, partlinelength,

						scanLineBuffer, drawMode);

				}

			}

		destX += partlinelength;

		}

	// multiple complete lines - columns

	TInt numcolumns = (destXlimit - destX) / srceWidth;

	if (numcolumns > 0)

		{

		TPoint srcecoord2(0, aSrceRect.iTl.iY);

		TInt desty = aDest.iY;

		TLineScanningPosition lineScanPos(aBase);

		if (useScanLinePtr)

			{

			if (aSrce->IsCompressed())

				{

				while (srcecoord2.iY < aSrceRect.iBr.iY)

					{

					TPoint coord(srcecoord2);

					aSrce->GetScanLinePtr (slptr, srceWidth, coord, aBase, lineScanPos);

					if (srcecoord2.iY == aSrceRect.iTl.iY)

						{

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

						}

					TInt tempdestX = destX;

					for (TInt count = 0; count < numcolumns; count++, tempdestX += srceWidth)

						{

						iDrawDevice->WriteLine(tempdestX, desty, srceWidth, slptr, drawMode);

						}

					srcecoord2.iY++;

					desty++;

					}

				}

			else

				{

				while (srcecoord2.iY < aSrceRect.iBr.iY)

					{

					TPoint coord(srcecoord2);

					aSrce->GetScanLinePtr (slptr, srceWidth, coord, aBase, lineScanPos);

					do

						{

						TInt tempdestX = destX;

						for (TInt count = 0; count < numcolumns; count++, tempdestX += srceWidth)

							{

							iDrawDevice->WriteLine (tempdestX, desty, srceWidth, slptr, drawMode);

							}

						slptr = (TUint32*)((TUint8*)slptr + aStride);

						srcecoord2.iY++;

						desty++;

						}

					while ((srcecoord2.iY < aSrceRect.iBr.iY) && (slptr < lastScanLine));

					}

				}

			}

		else

			{

			for (; srcecoord2.iY < aSrceRect.iBr.iY; srcecoord2.iY++, desty++)

				{

				TInt tempdestX = destX;

				TPoint coord(srcecoord2);

				aSrce->GetScanLinePtr (slptr, srceWidth, coord, aBase, lineScanPos);

				if (srcecoord2.iY == aSrceRect.iTl.iY)

					{

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

					}

				for (TInt count = 0; count < numcolumns; count++, tempdestX += srceWidth)

					{

					aSrce->GetScanLine(slptr, scanLineDes, coord, srceWidth,

							EFalse, KZeroPoint, dispMode);

					iDrawDevice->WriteLine(tempdestX, desty, srceWidth, scanLineBuffer, drawMode);

					}

				}

			}

		destX += numcolumns * srceWidth;

		}

	// final part line

	if (destX < destXlimit)

		{

		const TInt restofline = destXlimit - destX;

		TPoint srcecoord3(0, aSrceRect.iTl.iY);

		TInt desty = aDest.iY;

		TLineScanningPosition lineScanPos(aBase);

		if (useScanLinePtr)

			{

			offset = 0;

			if (aSrce->IsCompressed())

				{

				while (srcecoord3.iY < aSrceRect.iBr.iY)

					{

					scanLineBuffer = GetScanLineOffsetPtr (aSrce, slptr,

							srceWidth, srcecoord3, aBase, lineScanPos, offset);

					if (srcecoord3.iY == aSrceRect.iTl.iY)

						{

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

						}

					iDrawDevice->WriteLine(destX, desty, restofline, scanLineBuffer, drawMode);

					srcecoord3.iY++;

					desty++;

					}

				}

			else

				{

				while (srcecoord3.iY < aSrceRect.iBr.iY)

					{

					scanLineBuffer = GetScanLineOffsetPtr (aSrce, slptr,

							srceWidth, srcecoord3, aBase, lineScanPos, offset);

					do

						{

						iDrawDevice->WriteLine(destX, desty, restofline, scanLineBuffer, drawMode);

						scanLineBuffer = (TUint32*)((TUint8*)scanLineBuffer + aStride);

						srcecoord3.iY++;

						desty++;

						}

					while ((srcecoord3.iY < aSrceRect.iBr.iY) && (scanLineBuffer < lastScanLine));

					}

				}

			}

		else

			{

			for (; srcecoord3.iY < aSrceRect.iBr.iY; srcecoord3.iY++, desty++)

				{

				aSrce->GetScanLine (scanLineDes, srcecoord3, srceWidth, EFalse,

						KZeroPoint, dispMode, aBase, lineScanPos);

				if (srcecoord3.iY == aSrceRect.iTl.iY)

					{

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