// 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);
					}
				iDrawDevice->WriteLine(destX, desty, restofline, scanLineBuffer, drawMode);
				}
			}
		}
	}
/** 
Performs the masked bitblt to the device.

@param aDest The target position on the device which will contain the top left 
             corner of the source bitmap.
@param aSourceBitmap The bitmap object that contains the pixels to draw.
@param aSourceBase The address of the source bitmap pixels.
@param aSourceRect The area of the bitmap to draw from.
@param aMaskBitmap The bitmap object that contains the mask.
@param aMaskBase The address of the mask pixels.
@param aInvertMask Inverts the mask if ETrue.
@panic DGDIAdapter 1013, if aDest is outside of the device bounds (debug only).
*/
void CSwDirectGdiEngine::DoBitBltMasked(const TPoint& aDest,
		   CBitwiseBitmap* aSourceBitmap,
		   TUint32* aSourceBase,
		   const TRect& aSourceRect,
		   CBitwiseBitmap* aMaskBitmap,
		   TUint32* aMaskBase,
		   TBool aInvertMask)
	{
#ifdef _DEBUG
	TRect deviceDestRect;
	iDrawDevice->GetDrawRect (deviceDestRect);
#endif
	
    GRAPHICS_ASSERT_DEBUG (aDest.iX >= deviceDestRect.iTl.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG (aDest.iY >= deviceDestRect.iTl.iY, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG ((aDest.iX + aSourceRect.Width()) <= deviceDestRect.iBr.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG ((aDest.iY + aSourceRect.Height()) <= deviceDestRect.iBr.iY, EDirectGdiPanicOutOfBounds);	
	const TPoint KZeroPoint(0,0);

	MFastBlend* fastBlend=NULL;
	if (FastBlendInterface(aSourceBitmap,aMaskBitmap,fastBlend)==KErrNone)
		{
		if (fastBlend->FastBlendBitmapMasked(aDest, aSourceBase, aSourceBitmap->DataStride(), aSourceBitmap->SizeInPixels(), aSourceRect, aSourceBitmap->DisplayMode(),
							aMaskBase, aMaskBitmap->DataStride(), aMaskBitmap->DisplayMode(), aMaskBitmap->SizeInPixels(), aSourceRect.iTl, aInvertMask,
							GcDrawMode(iDrawMode), CFbsDrawDevice::ENoShadow)==KErrNone)
			{
			return;
			}
		}
	
	if (aMaskBitmap->DisplayMode() == EGray256)
		{
		DoBitBltAlpha (aDest, aSourceBitmap, aSourceBase, aSourceRect,
				aMaskBitmap, aMaskBase, aSourceRect.iTl, EFalse);
		}
	// if screen driver is 16MAP we avoid logical operator pen modes by using DoBitBltAlpha() for blitting
	else if(iDrawDevice->ScanLineDisplayMode() == EColor16MAP)
		{
		DoBitBltAlpha (aDest, aSourceBitmap, aSourceBase, aSourceRect,
				aMaskBitmap, aMaskBase, aSourceRect.iTl, aInvertMask);
		}
	else if (aSourceBitmap == aMaskBitmap)
		{
		const TInt width = aSourceRect.Width();
		const TDisplayMode dispMode = ScanLineBufferDisplayMode(iDrawDevice);
		const CGraphicsContext::TDrawMode drawMode = aInvertMask ? CGraphicsContext::EDrawModeAND : CGraphicsContext::EDrawModeOR;
		TPoint srcePoint(aSourceRect.iTl);
		TInt destY = aDest.iY;
		
		TLineScanningPosition lineScanPos(aSourceBase);

		const TBool useScanLinePtr = (dispMode == aSourceBitmap->DisplayMode() && 
				(TDisplayModeUtils::NumDisplayModeBitsPerPixel(dispMode)>=8));

		if (useScanLinePtr)
			{
			TUint32* scanLineBuffer = NULL;
			TUint32* slptr = NULL;
			TUint offset = MemoryOffsetForPixelPitch (srcePoint.iX, dispMode);

			if (aSourceBitmap->IsCompressed())
				{
				for ( ; srcePoint.iY < aSourceRect.iBr.iY; destY++,
						srcePoint.iY++)
					{
					scanLineBuffer = GetScanLineOffsetPtr (
							aSourceBitmap, slptr, width, srcePoint,
							aSourceBase, lineScanPos, offset);
					
					iDrawDevice->WriteLine (aDest.iX, destY, width,
							scanLineBuffer, drawMode);
					}
				}
			else
				{
				TUint stride = aSourceBitmap->DataStride ();
				TUint32* lastScanLine = aSourceBitmap->ScanLineAddress(aSourceBase, aSourceRect.iBr.iY-1);

				while (srcePoint.iY < aSourceRect.iBr.iY)
					{
					scanLineBuffer = GetScanLineOffsetPtr(aSourceBitmap, slptr, width, srcePoint,
							aSourceBase, lineScanPos, offset);
					do
						{
						iDrawDevice->WriteLine (aDest.iX, destY, width, scanLineBuffer, drawMode);
						scanLineBuffer = (TUint32*)((TUint8*)scanLineBuffer + stride);
						destY++;
						srcePoint.iY++;
						}
					while ((srcePoint.iY < aSourceRect.iBr.iY) && (scanLineBuffer < lastScanLine));
					}
				}
			}
		else
			{
			const TInt scanLineBytes = iDrawDevice->ScanLineBytes();
			TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();
			TPtr8 scanLineDes((TUint8*)scanLineBuffer, scanLineBytes,
					scanLineBytes);
			for (; srcePoint.iY < aSourceRect.iBr.iY; destY++,
					srcePoint.iY++)
				{
				aSourceBitmap->GetScanLine (scanLineDes, srcePoint,
						width, EFalse, KZeroPoint, dispMode,
						aSourceBase, lineScanPos);

				iDrawDevice->WriteLine (aDest.iX, destY, width,
						scanLineBuffer, drawMode);
				}
			}
		}
	else
		{
		DoBitBltMaskedFlicker(aDest, aSourceBitmap, aSourceBase,
				aSourceRect, aMaskBitmap, aMaskBase, aInvertMask);		
		}
	}
		
/**
@see DoBitBltMasked()
 */
void CSwDirectGdiEngine::DoBitBltMaskedFlicker(const TPoint& aDest,
				  CBitwiseBitmap* aSourceBitmap,
				  TUint32* aSourceBase,
				  const TRect& aSourceRect,
				  CBitwiseBitmap* aMaskBitmap,
				  TUint32* aMaskBase,
				  TBool aInvertMask)
	{
	const TInt width = aSourceRect.Width();
	TInt destY = aDest.iY;
	TPoint srcePoint(aSourceRect.iTl);
	
	TLineScanningPosition lineScanPos(aSourceBase);
	TLineScanningPosition lineScanPosMask(aMaskBase);
	
	const TDisplayMode srcFormat = aSourceBitmap->DisplayMode();
	const TDisplayMode maskFormat = aMaskBitmap->DisplayMode();
	
	if (aMaskBitmap->IsCompressed()) 
		{ 
		HBufC8* hBuf = CFbsBitmap::GetDecompressionBuffer(aMaskBitmap->DataStride() + 4);
		if (!hBuf) 
			{
			iDriver->SetError(KErrNoMemory);
			return; // Out of memory so do not draw anything 
			}
		lineScanPosMask.iScanLineBuffer = hBuf; 
		} 
	
	TAny* interface = NULL;
	if ( (srcFormat == EColor16MU || srcFormat == EColor64K ) &&
			maskFormat == EGray2 && 
			aSourceBitmap->SizeInPixels().iWidth <= aMaskBitmap->SizeInPixels().iWidth &&
			aSourceBitmap->SizeInPixels().iHeight <= aMaskBitmap->SizeInPixels().iHeight &&
			iDrawDevice->GetInterface(KFastBlitInterfaceID, interface) == KErrNone )
		{
		// Parameters allow optimised code path
		TInt length = width;
		TUint32* srcPtr=NULL;
		TUint32* maskPtr=NULL;
		MFastBlit* fastBlit = reinterpret_cast<MFastBlit*>(interface);
		while (srcePoint.iY < aSourceRect.iBr.iY)
			{
			aSourceBitmap->GetScanLinePtr(srcPtr, length, srcePoint, aSourceBase, lineScanPos);
			aMaskBitmap->GetScanLinePtr(maskPtr, length, srcePoint, aMaskBase, lineScanPosMask);
			
			fastBlit->WriteMaskLineEx(aDest.iX,destY,length,srcePoint.iX,srcPtr,srcFormat,srcePoint.iX,maskPtr,aInvertMask);
			
			destY++;
			++srcePoint.iY;
			}
		return;
		}
	
	const TDisplayMode dispMode = ScanLineBufferDisplayMode(iDrawDevice);
	const CGraphicsContext::TDrawMode drawMode = aInvertMask ? CGraphicsContext::EDrawModeAND : CGraphicsContext::EDrawModeANDNOT;
	
	TUint32* scanLineBuffer = iDrawDevice->ScanLineBuffer();
	const TInt scanLineBytes = iDrawDevice->ScanLineBytes();
	TPtr8 scanLineDes((TUint8*)scanLineBuffer,scanLineBytes,scanLineBytes);
	TLineScanningPosition lineScanPos2(aSourceBase);
	const TPoint KZeroPoint(0,0);
	
	//scanline modifications required if using different modes, bits per pixel less than 8
	if ( (dispMode == aSourceBitmap->DisplayMode()) && 
			(TDisplayModeUtils::NumDisplayModeBitsPerPixel(dispMode)>=8))
		{
		TUint offset = MemoryOffsetForPixelPitch(srcePoint.iX, dispMode);
		TUint32* slptr=NULL;
		//mask scanline modifications required for EInvertPen, different screen modes
		if ((drawMode != CGraphicsContext::EDrawModeANDNOT) && (dispMode == aMaskBitmap->DisplayMode()))
			{
			TUint32* scanLineBufferMask = NULL;
			//stride jumping not possible with compressed bitmaps
			if (aSourceBitmap->IsCompressed() || aMaskBitmap->IsCompressed())
				{
				for (; srcePoint.iY < aSourceRect.iBr.iY; destY++,srcePoint.iY++)
					{
					scanLineBuffer = GetScanLineOffsetPtr(aSourceBitmap, slptr, width, srcePoint, aSourceBase, lineScanPos, offset);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer, CGraphicsContext::EDrawModeXOR);
					scanLineBufferMask = GetScanLineOffsetPtr(aMaskBitmap, slptr, width, srcePoint, aMaskBase, lineScanPosMask, offset);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferMask,drawMode);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer, CGraphicsContext::EDrawModeXOR);
					}
				}
			else
				{
				TUint strideSrc = aSourceBitmap->DataStride();
				TUint strideMask = aMaskBitmap->DataStride();
				TUint32* lastScanLineSrc = aSourceBitmap->ScanLineAddress(aSourceBase,aSourceRect.iBr.iY-1);
				TUint32* lastScanLineMask = aMaskBitmap->ScanLineAddress(aMaskBase,aSourceRect.iBr.iY-1);

				while (srcePoint.iY < aSourceRect.iBr.iY)
					{
					scanLineBuffer = GetScanLineOffsetPtr(aSourceBitmap, slptr, width, srcePoint, aSourceBase, lineScanPos, offset);
					scanLineBufferMask = GetScanLineOffsetPtr(aMaskBitmap, slptr, width, srcePoint, aMaskBase, lineScanPosMask, offset);
					do
						{
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,CGraphicsContext::EDrawModeXOR);
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferMask,drawMode);
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,CGraphicsContext::EDrawModeXOR);
						destY++;
						srcePoint.iY++;
						}
					while ((srcePoint.iY < aSourceRect.iBr.iY) && 
							(scanLineBuffer < lastScanLineSrc) && 
							(scanLineBufferMask < lastScanLineMask)	&& 
							((scanLineBuffer = (TUint32*)((TUint8*)scanLineBuffer + strideSrc))>(TUint32*)0) && 
							((scanLineBufferMask = (TUint32*)((TUint8*)scanLineBufferMask + strideMask))>(TUint32*)0) );
					}
				}
			}
		else
			{
			TUint32* scanLineBufferPtr = NULL;
			//stride jumping not possible with compressed bitmaps
			if (aSourceBitmap->IsCompressed())
				{
				for (; srcePoint.iY < aSourceRect.iBr.iY; destY++,srcePoint.iY++)
					{
					scanLineBufferPtr = GetScanLineOffsetPtr(aSourceBitmap, slptr, width, srcePoint, aSourceBase, lineScanPos, offset);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferPtr,CGraphicsContext::EDrawModeXOR);
					aMaskBitmap->GetScanLine(scanLineDes,srcePoint,width,EFalse , KZeroPoint, dispMode, aMaskBase, lineScanPosMask);
					TileScanLine(scanLineDes, width, srcePoint, aMaskBitmap, lineScanPosMask, aMaskBase, dispMode);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,drawMode);
					iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferPtr,CGraphicsContext::EDrawModeXOR);
					}
				}
			else
				{
				TUint stride = aSourceBitmap->DataStride();
				TUint32* lastScanLine = aSourceBitmap->ScanLineAddress(aSourceBase,aSourceRect.iBr.iY-1);
				while (srcePoint.iY < aSourceRect.iBr.iY)
					{
					scanLineBufferPtr = GetScanLineOffsetPtr(aSourceBitmap, slptr, width, srcePoint, aSourceBase, lineScanPos, offset);
					do
						{
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferPtr,CGraphicsContext::EDrawModeXOR);
						aMaskBitmap->GetScanLine(scanLineDes,srcePoint,width,EFalse, KZeroPoint, dispMode,aMaskBase, lineScanPosMask);
						TileScanLine(scanLineDes, width, srcePoint, aMaskBitmap, lineScanPosMask, aMaskBase, dispMode);
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,drawMode);
						iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBufferPtr,CGraphicsContext::EDrawModeXOR);
						destY++;
						srcePoint.iY++;
						}
					while ((srcePoint.iY < aSourceRect.iBr.iY) && (scanLineBufferPtr < lastScanLine) && 
							((scanLineBufferPtr = (TUint32*)((TUint8*)scanLineBufferPtr + stride))>(TUint32*)0));
					}
				}
			}
		}
	else
		{
		for (; srcePoint.iY < aSourceRect.iBr.iY; destY++,srcePoint.iY++)
			{
			aSourceBitmap->GetScanLine(scanLineDes,srcePoint,width,EFalse, KZeroPoint,
					dispMode,aSourceBase,lineScanPos);
			
			iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,CGraphicsContext::EDrawModeXOR);
			aMaskBitmap->GetScanLine(scanLineDes,srcePoint,width,EFalse , KZeroPoint, dispMode,
					aMaskBase, lineScanPosMask);
			TileScanLine(scanLineDes, width, srcePoint, aMaskBitmap, lineScanPosMask, aMaskBase, dispMode);
			iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,drawMode);
			aSourceBitmap->GetScanLine(scanLineDes,srcePoint,width,EFalse , KZeroPoint ,dispMode,
					aSourceBase,lineScanPos2);		
			
			iDrawDevice->WriteLine(aDest.iX,destY,width,scanLineBuffer,CGraphicsContext::EDrawModeXOR);
			}
		}
	}		
				
/**
@see DoBitBltMasked()
 */
void CSwDirectGdiEngine::DoBitBltAlpha(const TPoint& aDest ,CBitwiseBitmap* aSourceBitmap,
		TUint32* aSourceBase, const TRect& aSourceRect,
		CBitwiseBitmap* aMaskBitmap, TUint32* aMaskBase,
		const TPoint& aAlphaPoint, TBool aInvertMask)
	{
	MFastBlend* fastBlend=NULL;
	if (FastBlendInterface(aSourceBitmap,aMaskBitmap,fastBlend)==KErrNone)
		{
		if (fastBlend->FastBlendBitmapMasked(aDest, aSourceBase, aSourceBitmap->DataStride(), aSourceBitmap->SizeInPixels(), aSourceRect, aSourceBitmap->DisplayMode(),
							aMaskBase, aMaskBitmap->DataStride(), aMaskBitmap->DisplayMode(), aMaskBitmap->SizeInPixels(), aAlphaPoint, aInvertMask,
							GcDrawMode(iDrawMode), CFbsDrawDevice::ENoShadow)==KErrNone)
			{
			return;
			}
		}

	const TPoint KZeroPoint(0,0);
	const TInt KScanLineLength = 256;
	const TInt KRgbSize = 4;
	
	TUint8 srceRgbBuffer[KScanLineLength * KRgbSize];
	TUint8 maskBuffer[KScanLineLength];
	TUint8* srceRgbBufferPtr(srceRgbBuffer);
	
	TPtr8 srceRgbDes(srceRgbBuffer, KScanLineLength * KRgbSize, KScanLineLength * KRgbSize);
	TPtr8 maskDes(maskBuffer, KScanLineLength, KScanLineLength);	
	
	TInt srceY = aSourceRect.iTl.iY;
	TInt destY = aDest.iY;
	TInt alphaY = aAlphaPoint.iY;
	
	TLineScanningPosition lineScanPosSrc(aSourceBase);
	TLineScanningPosition lineScanPosMask(aMaskBase);
	TDisplayMode sourceMode = aSourceBitmap->DisplayMode();
	
	if (aMaskBitmap->IsCompressed())
		{
		HBufC8* hBuf= CFbsBitmap::GetDecompressionBuffer(aMaskBitmap->DataStride());
		if (hBuf == NULL)
			{
			iDriver->SetError(KErrNoMemory); // Out of memory so do not draw anything
			return;
			}
		lineScanPosMask.iScanLineBuffer = hBuf;
		}
	
	TAny* interface = NULL;
	if ( (sourceMode == EColor16MU || sourceMode == EColor64K) &&
		aMaskBitmap->DisplayMode() == EGray256 && // ensure a monochrome mask isn't passed in as an alpha channel
		aSourceBitmap->SizeInPixels().iWidth <= aMaskBitmap->SizeInPixels().iWidth &&
		aSourceBitmap->SizeInPixels().iHeight <= aMaskBitmap->SizeInPixels().iHeight &&
		iDrawDevice->GetInterface(KFastBlitInterfaceID, interface) == KErrNone )
		{
		TInt length = aSourceRect.Width();
		const TInt srceX = aSourceRect.iTl.iX;
		const TInt alphaX = aAlphaPoint.iX;
		const TInt destX = aDest.iX;
		MFastBlit* fastBlit = reinterpret_cast<MFastBlit*>(interface);
		
		while (srceY < aSourceRect.iBr.iY)
			{
			TUint32* srcPtr;
			TUint32* maskPtr;
			TPoint srcPoint(srceX, srceY);
			TPoint maskPoint(alphaX, alphaY);
			
			aSourceBitmap->GetScanLinePtr(srcPtr, length, srcPoint, aSourceBase, lineScanPosSrc);
			aMaskBitmap->GetScanLinePtr(maskPtr, length, maskPoint, aMaskBase, lineScanPosMask);
			
			fastBlit->WriteAlphaLineEx(destX, destY, length, srceX, srcPtr,
					sourceMode, alphaX, maskPtr, MAlphaBlend::EShdwBefore);
			srceY++;
			destY++;
			alphaY++;
			}
		
		return;
		}
	
	const TBool useScanLinePtr = ( (EColor16MA == aSourceBitmap->DisplayMode()));
	TUint32* slptr = NULL;
	TUint offset = 0;
	
	while (srceY < aSourceRect.iBr.iY)
		{
		TInt srceX = aSourceRect.iTl.iX;
		TInt destX = aDest.iX;
		TInt alphaX = aAlphaPoint.iX;
		
		while (srceX < aSourceRect.iBr.iX)
			{
			TPoint srcePoint(srceX,srceY);
			TPoint alphaPoint(alphaX,alphaY);
			const TInt width = Min(KScanLineLength, aSourceRect.iBr.iX - srceX);
			
			if (useScanLinePtr)
				{
				offset = MemoryOffsetForPixelPitch(srceX, EColor16MU);
				srceRgbBufferPtr = (TUint8*)GetScanLineOffsetPtr(aSourceBitmap, slptr, width, 
						                       srcePoint, aSourceBase, lineScanPosSrc, offset);
				}
			else
				{
				aSourceBitmap->GetScanLine(srceRgbDes,srcePoint,width,EFalse,KZeroPoint,
						               ERgb,aSourceBase,lineScanPosSrc);
				}
			
			aMaskBitmap->GetScanLine(maskDes, alphaPoint, width, EFalse, KZeroPoint,
					                EGray256, aMaskBase, lineScanPosMask);
			TileScanLine(maskDes, width, alphaPoint, aMaskBitmap, lineScanPosMask, aMaskBase, EGray256);
			
			// aInvertMask is not used for alpha channels (EGray256 mask)
			if (aInvertMask && aMaskBitmap->DisplayMode() != EGray256)
				{
				for (TInt i = 0; i < width; ++i)
					{
					maskBuffer[i] = ~maskBuffer[i];
					}
				}
			
			iDrawDevice->WriteRgbAlphaLine(destX, destY, width, srceRgbBufferPtr, maskBuffer, GcDrawMode(iDrawMode));
			
			srceX += KScanLineLength;
			destX += KScanLineLength;
			alphaX += KScanLineLength;
			}
		
		srceY++;
		destY++;
		alphaY++;
		}		
	}

/**
Tiles the scan line if its length in pixels is less than aLengthInPixels.

@param aScanLine A pointer to the scan line buffer.
@param aLengthInPixels The scan line size in pixels.
@param aSrcPt Position of the first pixel in aMaskBitmap that should be used as a source
              for the pixels in scan line buffer.
@param aMaskBitmap Any additional pixels for the scan line buffer will be taken from here.
@param aScanLinePos This argument is used for some internal optimisations. It should not be
                    modified by the caller.
@param aMaskBase The base address of aMaskBitmap data.
@param aDisplayMode Any additional pixels should be taken from aMaskBitmap using aDisplayMode
                    as an argument for GetScanLine() call.
@panic DGDIAdapter 1021, if the memory required for the scanline is greater than the size of aScanLine (debug only).
*/
void CSwDirectGdiEngine::TileScanLine(TPtr8& aScanLine,
						  TInt aLengthInPixels,
						  const TPoint& aSrcPt,
						  const CBitwiseBitmap* aMaskBitmap,
						  TLineScanningPosition& aScanLinePos,
						  TUint32* aMaskBase,
						  TDisplayMode aDisplayMode
						  )
	{
	TInt lengthInBytes = CFbsBitmap::ScanLineLength(aLengthInPixels, aDisplayMode);
	GRAPHICS_ASSERT_DEBUG(lengthInBytes <= aScanLine.MaxLength(), EDirectGdiPanicInvalidArg);
	TInt scanLineLength = aScanLine.Length();
	if(scanLineLength < lengthInBytes && aSrcPt.iX > 0)
		{
		//If, for example, src bmp is 100 pixels width, mask bmp is 20 pixels width and src
		//rect is (10, 0, 100, 1) -> We will read only pixels 10..19 from the first scan line
		//of the mask bmp. We have to have 90 mask bmp pixels.
		//So we have to make a second mask bmp read startig from pixel 0 - 10 pixels length.
		TInt maxLen = Min(aScanLine.MaxLength() - scanLineLength, aSrcPt.iX);
		TPtr8 maskDes2(const_cast <TUint8*> (aScanLine.Ptr()) + scanLineLength, maxLen, maxLen);
		TPoint srcPt(0, aSrcPt.iY);
		TPoint zeroPt(0, 0);
		aMaskBitmap->GetScanLine(maskDes2, srcPt, maxLen, EFalse, zeroPt, aDisplayMode, aMaskBase, aScanLinePos);
		aScanLine.SetLength(scanLineLength + maskDes2.Length());
		scanLineLength = aScanLine.Length();
		}
	if(scanLineLength >= lengthInBytes || scanLineLength == 0)
		{
		return;
		}
	//If we still don't have enough mask bmp pixels - we have to tile the scan line
	TInt repeatCnt = lengthInBytes / scanLineLength - 1;
	TInt bytesLeft = lengthInBytes % scanLineLength;
	const TUint8* src = aScanLine.Ptr();
	TUint8* dest = const_cast <TUint8*> (src) + scanLineLength;
	for(;repeatCnt>0;dest+=scanLineLength,repeatCnt--)
		{
		Mem::Copy(dest, src, scanLineLength);
		}
	if(bytesLeft)
		{
		Mem::Copy(dest, src, bytesLeft);
		}
	aScanLine.SetLength(lengthInBytes);
	}

/**
Draws a masked rectangular section of the source bitmap and does a compress/stretch to 
fit a given destination rectangle. It uses DoBitBltMasked() if no stretching is involved. 

@see DrawBitmapMasked()

@param aDestRect The target position on the device containing the top left corner of the source bitmap.
@param aSourceBitmap The bitmap object that contains the pixels to draw.
@param aSourceBase The address of the source bitmap pixels.
@param aSourceRect The area of the bitmap to draw from.
@param aMaskBitmap The bitmap object that contains the mask.
@param aMaskBase The address of the mask pixels.
@param aInvertMask Inverts the mask if ETrue.
@param aClipRect A clipping rectangle.
@panic DGDIAdapter 1013, if the clipping rectangle is fully outside of the device bounds (debug only).
*/
void CSwDirectGdiEngine::DoDrawBitmapMasked(const TRect& aDestRect,
							   CBitwiseBitmap* aSourceBitmap,
							   TUint32* aSourceBase,
							   const TRect& aSourceRect,
							   CBitwiseBitmap* aMaskBitmap,
							   TUint32* aMaskBase,
							   TBool aInvertMask,
							   const TRect& aClipRect)
	{
	CFbsDrawDevice* drawDevice = iDrawDevice;
#ifdef _DEBUG
	TRect deviceDestRect;
	drawDevice->GetDrawRect(deviceDestRect);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iTl.iX >= deviceDestRect.iTl.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iTl.iY >= deviceDestRect.iTl.iY, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iBr.iX <= deviceDestRect.iBr.iX, EDirectGdiPanicOutOfBounds);
	GRAPHICS_ASSERT_DEBUG(aClipRect.iBr.iY <= deviceDestRect.iBr.iY, EDirectGdiPanicOutOfBounds);
#endif

	// The clipped version of the destination rectangle
	TRect clippedDestRect(aDestRect);
	clippedDestRect.Intersection(aClipRect);

	// If the source rectangle and the destination rectangle are same,
	// no stretch/compress operation required, just do BitBltMasked
	if (aDestRect.Size() == aSourceRect.Size())
		{
		if (!clippedDestRect.IsEmpty())
			{
			const TPoint destPoint(clippedDestRect.iTl);
			clippedDestRect.Move(aSourceRect.iTl - aDestRect.iTl);
			DoBitBltMasked(destPoint,
						   aSourceBitmap,
						   aSourceBase,
						   clippedDestRect,
						   aMaskBitmap,
						   aMaskBase,
						   aInvertMask);
			}
		return;
		}

	MFastBlend* fastBlend=NULL;
	if (FastBlendInterface(aSourceBitmap,aMaskBitmap,fastBlend)==KErrNone)
		{
		if (fastBlend->FastBlendBitmapMaskedScaled(aClipRect, aDestRect, aSourceRect, aSourceBase, aSourceBitmap->DataStride(),
				aSourceBitmap->DisplayMode(),aSourceBitmap->SizeInPixels(), 
				aMaskBase, aMaskBitmap->DataStride(), aMaskBitmap->DisplayMode(), aMaskBitmap->SizeInPixels(), aInvertMask, 
				GcDrawMode(iDrawMode), CFbsDrawDevice::ENoShadow)==KErrNone)
			{
			return;
			}
		}
	
	TUint32* scanLineBuffer = drawDevice->ScanLineBuffer();
	const TInt scanLineBytes = drawDevice->ScanLineBytes();
	TPtr8 scanLineDes(reinterpret_cast<TUint8*>(scanLineBuffer),scanLineBytes,scanLineBytes);

	const TInt KScanLineLength = 256;
	const TInt KRgbSize = 4;
	TUint8 maskBuffer[KScanLineLength];

	TUint8 sourceBuffer[KScanLineLength*KRgbSize];
	TPtr8 sourceDes(sourceBuffer,KScanLineLength*KRgbSize,KScanLineLength*KRgbSize);

	const TDisplayMode dispMode = ScanLineBufferDisplayMode(drawDevice);
	CGraphicsContext::TDrawMode drawMode = aInvertMask ? CGraphicsContext::EDrawModeAND : CGraphicsContext::EDrawModeANDNOT;
	// If the source bitmap and the mask bitmap are same, draw the source bitmap either
	// with EDrawModeAND or EDrawModeOR based on aInvertMask parameter.
	if (aSourceBitmap == aMaskBitmap)
		{
		drawMode = aInvertMask ? CGraphicsContext::EDrawModeAND : CGraphicsContext::EDrawModeOR;
		}

	TLinearDDA xLine;
	TInt bitmapXStart = 0;
	xLine.Construct(TPoint(aSourceRect.iTl.iX,aDestRect.iTl.iX),
					TPoint(aSourceRect.iBr.iX,aDestRect.iBr.iX),TLinearDDA::ELeft);
	xLine.JumpToYCoord2(bitmapXStart,clippedDestRect.iTl.iX);

	TLinearDDA yLine;
	TPoint yCoord(aSourceRect.iTl.iY,aDestRect.iTl.iY);
	yLine.Construct(yCoord,TPoint(aSourceRect.iBr.iY,aDestRect.iBr.iY),TLinearDDA::ELeft);
	TInt dummy;
	yLine.JumpToYCoord2(dummy,clippedDestRect.iTl.iY);
	yCoord.SetXY(dummy,clippedDestRect.iTl.iY);

	const TInt srceWidth = aSourceRect.Width();
	const TInt destWidth = aDestRect.Width();
	const TInt clipWidth = clippedDestRect.Width();
	const TInt clipStrch = clippedDestRect.iTl.iX - aDestRect.iTl.iX;
	const TInt sourceBmpWidth = aSourceBitmap->SizeInPixels().iWidth;
	const TInt maskWidth = aMaskBitmap->SizeInPixels().iWidth;
	const TInt maskHeight = aMaskBitmap->SizeInPixels().iHeight;

	TLineScanningPosition lineScanPos(aSourceBase);
	TLineScanningPosition lineScanPos2(aSourceBase);
	TLineScanningPosition lineScanPosMask(aMaskBase);

	HBufC8* alphaBuffer = NULL;
	TPtr8 alphaBufferDes(NULL, 0);
	const TDisplayMode maskDisplayMode = aMaskBitmap->DisplayMode();

	// Mask inversion is not supported if the original source mask format is EGray256.
	// Note that this is only used for pre-multiplied alpha targets.
	TUint8 maskInverter = (aInvertMask && maskDisplayMode != EGray256) ? 0xFF : 0x00;

	if (aSourceBitmap != aMaskBitmap)
		{
		// Get buffer to be used to convert non-EGray256 masks to EGray256 when display mode is EColor16MAP
		// or to tile the mask when the mask width is smaller than the source bitmap width.
		if (maskDisplayMode != EGray256 && (dispMode == EColor16MAP || maskWidth < sourceBmpWidth))
			{
			alphaBuffer = CFbsBitmap::GetExtraBuffer(CFbsBitmap::ScanLineLength(maskWidth, EGray256));
			if (!alphaBuffer)
				{
				return;  // Out of memory so do not draw anything 
				}
			alphaBufferDes.Set(alphaBuffer->Des());
			}

		// Get buffer to be used for decompressing compressed masks when mask is EGray256
		if (maskDisplayMode == EGray256 && aMaskBitmap->IsCompressed())
			{
			HBufC8* hBuf= CFbsBitmap::GetDecompressionBuffer(aMaskBitmap->DataStride());
			if (!hBuf)
				{
				return;  // Out of memory so do not draw anything
				}
			lineScanPosMask.iScanLineBuffer = hBuf;
			}
		}
	const TPoint KZeroPoint(0,0);

	while (yCoord.iY < clippedDestRect.iBr.iY)
		{
		// Draw only the source bitmap, if the source bitmap and the mask bitmap are same.
		// else draw both the bitmaps
		if (aSourceBitmap == aMaskBitmap)
			{
			aSourceBitmap->StretchScanLine(scanLineDes,TPoint(bitmapXStart,yCoord.iX),
								 clipStrch,clipWidth,destWidth,aSourceRect.iTl.iX,
								 srceWidth, KZeroPoint,dispMode,aSourceBase,lineScanPos);
			if (yCoord.iY==clippedDestRect.iTl.iY)
				aSourceBitmap->SetCompressionBookmark(lineScanPos,aSourceBase,NULL);
			drawDevice->WriteLine(clippedDestRect.iTl.iX,yCoord.iY,clipWidth,scanLineBuffer,drawMode);
			}
		else if ((maskDisplayMode == EGray256) || (dispMode == EColor16MAP))
			{
			// Stretch the source bitmap and the mask bitmap for KScanLineLength as stretch length
			// then do alpha blending for this length. If the length is more then KScanLineLength
			// repeat it till you stretch complete destination length.
			const TPoint startPt(bitmapXStart,yCoord.iX);
			TInt clipWidthPart = clippedDestRect.Width();
			TBool loopLast = ETrue;
			if(clipWidthPart > KScanLineLength)
				{
				clipWidthPart = KScanLineLength;
				loopLast = EFalse;
				}
			TInt clipIncStrch = clippedDestRect.iTl.iX - aDestRect.iTl.iX;
			TInt startClip=clippedDestRect.iTl.iX;
			TPoint sourceDestXCoords(bitmapXStart,clippedDestRect.iTl.iX);
			xLine.Construct(TPoint(aSourceRect.iTl.iX,aDestRect.iTl.iX),
							TPoint(aSourceRect.iBr.iX,aDestRect.iBr.iX),TLinearDDA::ELeft);
			xLine.JumpToYCoord2(sourceDestXCoords.iX,sourceDestXCoords.iY);
			TPoint srcPixel(bitmapXStart % maskWidth,yCoord.iX % maskHeight);
			TInt spaceLeft = 0;
			TRgb maskRgbValue;
			TUint32* maskScanLinePtr32 = NULL;
			TPoint currentYValue(0,srcPixel.iY);
			aMaskBitmap->GetScanLinePtr(maskScanLinePtr32, currentYValue, maskWidth, aMaskBase, lineScanPosMask);
			// To implement non EGray256 mask support with EColor16MAP display mode, we convert
			// the mask to EGray256.
			if (maskDisplayMode != EGray256) // Convert scan-line to EGray256 and set maskScanLinePtr32 to the conversion.
				{
				aMaskBitmap->GetScanLine(maskScanLinePtr32, alphaBufferDes, currentYValue, maskWidth, EFalse, TPoint(0, 0), EGray256);
				maskScanLinePtr32 = (TUint32*)alphaBuffer->Ptr();
				}
			TUint8* maskScanLinePtr = reinterpret_cast<TUint8*>(maskScanLinePtr32);

			// Outer loop over all KScanLineLengths
			FOREVER
				{
				aSourceBitmap->StretchScanLine(sourceDes,startPt,clipIncStrch,clipWidthPart,destWidth,
								aSourceRect.iTl.iX,srceWidth, KZeroPoint ,EColor16MU,aSourceBase,lineScanPos);
				// Inner loop to tile the mask if necessary
				spaceLeft = clipWidthPart;
				do	{
					srcPixel.iX = sourceDestXCoords.iX % maskWidth;
			
					// Invert the mask using the inversion mask.
					maskBuffer[(sourceDestXCoords.iY-clippedDestRect.iTl.iX)%KScanLineLength]=
						maskInverter^maskScanLinePtr[srcPixel.iX];
					xLine.NextStep(sourceDestXCoords);
					} while (--spaceLeft>0);
				
				if (yCoord.iY == clippedDestRect.iTl.iY && startClip == clippedDestRect.iTl.iX)
					{
					aSourceBitmap->SetCompressionBookmark(lineScanPos,aSourceBase,NULL);
					aMaskBitmap->SetCompressionBookmark(lineScanPosMask,aMaskBase,NULL);
					}
				drawDevice->WriteRgbAlphaLine(startClip,yCoord.iY,clipWidthPart,sourceBuffer,maskBuffer, GcDrawMode(iDrawMode));
				if (loopLast)
					{
					break;
					}
				startClip+=KScanLineLength;
				if (clippedDestRect.iBr.iX - startClip <= KScanLineLength)
 					{
					loopLast = ETrue;
					clipWidthPart = clippedDestRect.iBr.iX - startClip;
					}
				clipIncStrch += KScanLineLength;
				}
			}
		else
			{
			aSourceBitmap->StretchScanLine(scanLineDes,TPoint(bitmapXStart,yCoord.iX),
									 clipStrch,clipWidth,destWidth,aSourceRect.iTl.iX,
									 srceWidth, KZeroPoint ,dispMode,aSourceBase,lineScanPos2);
			drawDevice->WriteLine(clippedDestRect.iTl.iX,yCoord.iY,clipWidth,scanLineBuffer,CGraphicsContext::EDrawModeXOR);

			TInt maskXStart = bitmapXStart % maskWidth;
			if(maskWidth < sourceBmpWidth)
				{
				TPoint sourceDestXCoords(bitmapXStart,clippedDestRect.iTl.iX);
				xLine.Construct(TPoint(aSourceRect.iTl.iX,aDestRect.iTl.iX),
								TPoint(aSourceRect.iBr.iX,aDestRect.iBr.iX),TLinearDDA::ELeft);
				xLine.JumpToYCoord2(sourceDestXCoords.iX,sourceDestXCoords.iY);
				TPoint srcPixel(maskXStart,yCoord.iX % maskHeight);
				TInt spaceLeft = clipWidth;
				TPoint prevSourceDestXCoords(-1,-1);
				TRgb maskRgbValue;
				aMaskBitmap->GetScanLine(alphaBufferDes, TPoint(0,srcPixel.iY), maskWidth, EFalse, TPoint(0, 0), EGray256, aMaskBase, lineScanPosMask);

				// Loop to tile the mask
				do	{
					if (sourceDestXCoords.iY != prevSourceDestXCoords.iY)
						{
						if (sourceDestXCoords.iX != prevSourceDestXCoords.iX)
							{
							srcPixel.iX = sourceDestXCoords.iX % maskWidth;
							if (srcPixel.iX < 0)
								srcPixel.iX += maskWidth;
							maskRgbValue = TRgb::Gray256((*alphaBuffer)[srcPixel.iX]);
							}
						drawDevice->WriteRgb(sourceDestXCoords.iY,yCoord.iY,maskRgbValue,drawMode);
						spaceLeft--;
						}
					prevSourceDestXCoords = sourceDestXCoords;
					xLine.SingleStep(sourceDestXCoords);
					} while (spaceLeft > 0);
				}
			else
				{
				// No need to tile the mask
				aMaskBitmap->StretchScanLine(scanLineDes,TPoint(maskXStart,yCoord.iX % maskHeight),
										clipStrch,clipWidth,destWidth,aSourceRect.iTl.iX,
										srceWidth, KZeroPoint ,dispMode,aMaskBase,lineScanPosMask);
				drawDevice->WriteLine(clippedDestRect.iTl.iX,yCoord.iY,clipWidth,scanLineBuffer,drawMode);
				// Redo stretching of the aSourceBitmap scanline
				aSourceBitmap->StretchScanLine(scanLineDes,TPoint(bitmapXStart,yCoord.iX),
									 	clipStrch,clipWidth,destWidth,aSourceRect.iTl.iX,
									 	srceWidth, KZeroPoint ,dispMode,aSourceBase,lineScanPos2);
				}

			if (yCoord.iY==clippedDestRect.iTl.iY)
				{
				aSourceBitmap->SetCompressionBookmark(lineScanPos2,aSourceBase,NULL);
				aMaskBitmap->SetCompressionBookmark(lineScanPosMask,aMaskBase,NULL);
				}

			drawDevice->WriteLine(clippedDestRect.iTl.iX,yCoord.iY,clipWidth,scanLineBuffer,CGraphicsContext::EDrawModeXOR);
			}
		yLine.NextStep(yCoord);
		}
	}

TInt CSwDirectGdiEngine::FastBlendInterface(const CBitwiseBitmap* aSource, const CBitwiseBitmap* aMask, MFastBlend*& aFastBlend) const
	{
	#if defined(__ALLOW_FAST_BLEND_DISABLE__)
	if (iFastBlendDisabled)
		return(KErrNotSupported);
	#endif
	if ((aSource && aSource->IsCompressed()) || (aMask && aMask->IsCompressed()))
		return(KErrNotSupported);
	TAny* interface=NULL;
	TInt ret= iDrawDevice->GetInterface(KFastBlendInterfaceID, interface);
	aFastBlend=(MFastBlend*)interface;
	return(ret);
	}

/*
Returns the pixel-format to be used when extracting a scan-line through CBitwiseBitmap::GetScanLine(), CBitwiseBitmap::GetVerticalScanLine(), and CBitwiseBitmap::StretchScanLine() for consumption by CFbsDrawDevice::WriteLine() and associated methods.

@see CBitwiseBitmap::GetScanLine()
@see CBitwiseBitmap::GetVerticalScanLine()
@see CBitwiseBitmap::StretchScanLine()
@see CFbsDrawDevice::WriteLine()
@internalComponent
*/
TDisplayMode CSwDirectGdiEngine::ScanLineBufferDisplayMode(CFbsDrawDevice* aDrawDevice)
	{
	return iDrawMode == DirectGdi::EDrawModeWriteAlpha ? aDrawDevice->DisplayMode() : aDrawDevice->ScanLineDisplayMode();
	}