// 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 "BMDRAW.H"

#include "BitDrawInterfaceId.h"

// CDrawEightBppBitmapCommon

//EColor256 screen/bitmap device might be scaled.

//In this case right-bottom coordinate might go outside the drawing rectangle.

//Then - we need to check that we do not try to draw something outside the drawing rectangle.

//Initializes iSize, iDrawRect, iLongWidth, iScanlineWords data members.

//It should be called every time when iSize is going to be changed - from Construct().

//@param aSize Physical screen size in pixels.

//@panic EScreenDriverPanicInvalidSize - Invalid aSize parameter. This might happen if the 

//device is scaled and the scaling origin goes outside physical drawing rectangle.

void CDrawEightBppBitmapCommon::SetSize(const TSize& aSize) 

	{

	CDrawBitmap::SetSize(aSize);

	__ASSERT_DEBUG(iSize == aSize, User::Invariant());

	iLongWidth = (iSize.iWidth + 3) & ~3;

	iScanLineWords = iLongWidth / 4;

	}

TInt CDrawEightBppBitmapCommon::Construct(TSize aSize, TInt aStride)

	{

	iBits = NULL;

	CDrawBitmap::SetSize(aSize);

	__ASSERT_DEBUG(iSize == aSize, User::Invariant());

	if (aStride & 3)

		return KErrArgument;

	iLongWidth = aStride;

	if (iLongWidth < aSize.iWidth)

		return KErrArgument;

	iScanLineWords = aStride >> 2;

	TInt size = Max(aSize.iWidth,aSize.iHeight);

	if(size < 0)

		return KErrArgument;

	iScanLineBuffer = (TUint32*)(User::Heap().Alloc(size));

	if(iScanLineBuffer == NULL)

		return KErrNoMemory;

	return KErrNone;

	}

//aX, aY - physical coordinates

TUint8* CDrawEightBppBitmapCommon::PixelAddress(TInt aX,TInt aY) const

	{

	return (TUint8*)iBits + aY * iLongWidth + aX;

	}

void CDrawEightBppBitmapCommon::InvertBuffer(TInt aLength,TUint32* aBuffer)

	{

	const TUint32* limit = aBuffer + (aLength + 3) / 4;

	while (aBuffer < limit)

		*aBuffer++ ^= 0xffffffff;

	}

//CDrawEightBppBitmapCommon::ReadLine() called from CDrawBitmap::ReadLine()

//aX and aY - physical coordinates.

//Reads aLength pixel values and places them in aBuffer.

//aBuffer size should be at least aLength.

void CDrawEightBppBitmapCommon::ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer) const

	{

	const TUint8* pixelPtr = PixelAddress(aX,aY);

	if (iOrientation == EOrientationNormal && iScalingOff)

		Mem::Copy(aBuffer,pixelPtr,aLength);

	else

		{

		register TInt pixelPtrInc = LogicalPixelAddressIncrement();

		TUint8* bufferPtr = static_cast <TUint8*> (aBuffer);

		const TUint8* bufferPtrLimit = bufferPtr + aLength;

		while (bufferPtr < bufferPtrLimit)

			{

			*bufferPtr++ = *pixelPtr;

			pixelPtr += pixelPtrInc;

			}

		}

	}

//CDrawEightBppBitmapCommon::WriteRgb() called from exported CDrawBitmap::WriteRgb()

//aX, aY - physical coordinates

void CDrawEightBppBitmapCommon::WriteRgb(TInt aX,TInt aY,TUint8 aPixel)

	{

	register TUint8* pixelAddr = PixelAddress(aX, aY);

	if(iScalingOff)

		{

		*pixelAddr = aPixel;

		}

	else

		{

		const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

		const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

		const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

		SetPixels(pixelAddr, aPixel, pixelRowPtrLimit, bitsStart, bitsEnd);

		}

	}

//CDrawEightBppBitmapCommon::WriteBinary() called from exported CDrawBitmap::WriteBinary()

//aX, aY - logical coordinates

//"aData" parameter has "aHeight" 32 bits words

//"aLength" parameter tells how many bits (up to 32) has to be used from each 32 bit word

//This method is used for bitmap font symbols drawing

//One possible optimization: If "no scaling" And "pixelPtrInc == 1" Then

//writing could be made on 32 bits words (they has to be aligned before the operation)

void CDrawEightBppBitmapCommon::WriteBinary(TInt aX,TInt aY,TUint32* aData,TInt aLength,

											TInt aHeight,TUint8 aPixel)

	{

	DeOrientate(aX,aY);//aX, aY - physical coordinates

	TInt pixelInc;

	TInt rowInc;

	SetPixelInc(pixelInc, rowInc);

	const TUint32* dataLimit = aData + aHeight;

	register TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

	const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

	TInt orgY = aY;

	while (aData < dataLimit)

		{

		register TUint32 dataWord = *aData++;

		register TUint32 dataMask = 1;

		register TUint8* tempPixelPtr = pixelPtr;

		if(iScalingOff)

			{

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					*tempPixelPtr = aPixel;

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			}

		else

			{

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

					SetPixels(tempPixelPtr, aPixel, pixelRowPtrLimit, bitsStart, bitsEnd);

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				IncScaledY(aY);

				}

			}

		pixelPtr += rowInc;

		IncScaledY(aY, orgY);

		}

	}

//CDrawEightBppBitmapCommon::WriteBinaryOp() called from exported CDrawBitmap::WriteBinary()

//aX, aY - logical coordinates

//"aData" parameter has "aHeight" 32 bits words

//"aLength" parameter tells how many bits (up to 32) has to be used from each 32 bit word

//This method is used for bitmap font symbols drawing

//One possible optimization: If "no scaling" And "pixelPtrInc == 1" Then

//writing could be made on 32 bits words (they has to be aligned before the operation)

void CDrawEightBppBitmapCommon::WriteBinaryOp(TInt aX,TInt aY,TUint32* aData,TInt aLength,

											  TInt aHeight,TUint8 aPixel,

											  CGraphicsContext::TDrawMode aDrawMode)

	{

	if(aLength <= 0)

		{

		return;

		}

	DeOrientate(aX,aY);//aX, aY - physical coordinates

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint32* dataPtrLimit = aData + aHeight;

	register TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;

	TInt pixelInc;

	TInt rowInc;

	SetPixelInc(pixelInc, rowInc);

	const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

	const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

	TInt orgY = aY;

	if(aPixel)

		{

		while(aData < dataPtrLimit)

			{

			register TUint32 dataWord = *aData++;

			register TUint32 dataMask = 1;

			register TUint8* tempPixelPtr = pixelPtr;

			if(iScalingOff)

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

						if(aDrawMode==CGraphicsContext::EDrawModeXOR)

							{

							*tempPixelPtr ^= aPixel;

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeAND)

							{

							*tempPixelPtr &= aPixel;

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeOR)

							{

							*tempPixelPtr |= aPixel;

							}

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			else

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

						const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

						if(aDrawMode==CGraphicsContext::EDrawModeXOR)

							{

							XORPixels(tempPixelPtr, aPixel, pixelRowPtrLimit, bitsStart, bitsEnd);

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeAND)

							{

							ANDPixels(tempPixelPtr, aPixel, pixelRowPtrLimit, bitsStart, bitsEnd);

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeOR)

							{

							ORPixels(tempPixelPtr, aPixel, pixelRowPtrLimit, bitsStart, bitsEnd);

							}

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					IncScaledY(aY);

					}

				}

			pixelPtr += rowInc;

			IncScaledY(aY, orgY);

			}

		}

	else if(aDrawMode==CGraphicsContext::EDrawModeAND)

		{

		while(aData < dataPtrLimit)

			{

			register TUint32 dataWord = *aData++;

			register TUint32 dataMask = 1;

			register TUint8* tempPixelPtr = pixelPtr;

			if(iScalingOff)

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

						*tempPixelPtr = 0;

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			else

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

						const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

						SetPixels(tempPixelPtr, TUint8(0), pixelRowPtrLimit, bitsStart, bitsEnd);

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			pixelPtr += rowInc;

			IncScaledY(aY, orgY);

			}

		}

	}

//aX, aY - logical coordinates

//"aData" parameter has 32 bits words

//"aLength" parameter tells how many pixels have to be written

//This method is used for bitmap font symbols vertical drawing

//The method should not be called if the scaling is ON!

void CDrawEightBppBitmapCommon::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aData,

														TInt aLength,TUint8 aPixel,TBool aUp)

	{

	__ASSERT_DEBUG(iScalingOff, User::Invariant());

	DeOrientate(aX,aY);//aX, aY - physical coordinates

	TInt scanlineByteLength;

	switch(iOrientation)

		{

		case EOrientationNormal:

			scanlineByteLength = iLongWidth;

			break;

		case EOrientationRotated90:

			scanlineByteLength = -1;

			break;

		case EOrientationRotated180:

			scanlineByteLength = -iLongWidth;

			break;

		default: // EOrientationRotated270

			scanlineByteLength = 1;

		}

	if (aUp)

		scanlineByteLength = -scanlineByteLength;

	register TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8* pixelPtrLimit = pixelPtr + aLength * scanlineByteLength;

	register TUint32 dataWord = *aData;

	register TUint32 dataMask = 1;

	while(pixelPtr != pixelPtrLimit)

		{

		if(!dataMask)

			{

			dataMask = 1;

			aData++;

			dataWord = *aData;

			}

		if(dataWord & dataMask)

			{

			*pixelPtr = aPixel;

			}

		dataMask <<= 1;

		pixelPtr += scanlineByteLength;

		}

	}

//CDrawEightBppBitmapCommon::WriteLine() called from CDrawBitmap::WriteLine()

//aX and aY - physical coordinates

void CDrawEightBppBitmapCommon::WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	if (iOrientation == EOrientationNormal && iScalingOff)

		{

		Mem::Copy(pixelPtr,aBuffer,aLength);

		}

	else

		{

		register TInt pixelPtrInc = LogicalPixelAddressIncrement();

		TUint8* bufferPtr = reinterpret_cast <TUint8*> (aBuffer);

		const TUint8* bufferPtrLimit = bufferPtr + aLength;

		if(iScalingOff)

			{

			while(bufferPtr < bufferPtrLimit)

				{

				*pixelPtr = *bufferPtr++;

				pixelPtr += pixelPtrInc;

				}

			}

		else

			{

			const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

			const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

			while(bufferPtr < bufferPtrLimit)

				{

				const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

				SetPixels(pixelPtr, *bufferPtr++, pixelRowPtrLimit, bitsStart, bitsEnd);

				pixelPtr += pixelPtrInc;

				IncScaledY(aY);

				}

			}

		}

	}

//CDrawEightBppBitmapCommon::WriteLineXOR() called from CDrawBitmap::WriteLine()

//aX and aY - physical coordinates

//One possible optimization: If "no scaling" And "pixelPtrInc == 1" Then

//XOR could be made on 32 bits words (they  has to be aligned before the operation)

void CDrawEightBppBitmapCommon::WriteLineXOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	register TInt pixelPtrInc = LogicalPixelAddressIncrement();

	TUint8* bufferPtr = reinterpret_cast <TUint8*> (aBuffer);

	const TUint8* bufferPtrLimit = bufferPtr + aLength;

	if(iScalingOff)

		{

		while(bufferPtr < bufferPtrLimit)

			{

			*pixelPtr ^= *bufferPtr++;

			pixelPtr += pixelPtrInc;

			}

		}

	else

		{

		const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

		const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

		while(bufferPtr < bufferPtrLimit)

			{

			const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

			XORPixels(pixelPtr, *bufferPtr++, pixelRowPtrLimit, bitsStart, bitsEnd);

			pixelPtr += pixelPtrInc;

			IncScaledY(aY);

			}

		}

	}

//CDrawEightBppBitmapCommon::WriteLineAND() called from CDrawBitmap::WriteLine()

//aX and aY - deorientated and scaled

//aLength - not scaled

//One possible optimization: If "no scaling" And "pixelPtrInc == 1" Then

//AND could be made on 32 bits words (they  has to be aligned before the operation)

void CDrawEightBppBitmapCommon::WriteLineAND(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	register TInt pixelPtrInc = LogicalPixelAddressIncrement();

	TUint8* bufferPtr = reinterpret_cast <TUint8*> (aBuffer);

	const TUint8* bufferPtrLimit = bufferPtr + aLength;

	if(iScalingOff)

		{

		while(bufferPtr < bufferPtrLimit)

			{

			*pixelPtr &= *bufferPtr++;

			pixelPtr += pixelPtrInc;

			}

		}

	else

		{

		const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

		const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

		while(bufferPtr < bufferPtrLimit)

			{

			const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

			ANDPixels(pixelPtr, *bufferPtr++, pixelRowPtrLimit, bitsStart, bitsEnd);

			pixelPtr += pixelPtrInc;

			IncScaledY(aY);

			}

		}

	}

//CDrawEightBppBitmapCommon::WriteLineOR() called from CDrawBitmap::WriteLine()

//aX and aY - physical coordinates

//One possible optimization: If "no scaling" And "pixelPtrInc == 1" Then

//OR could be made on 32 bits words (they  has to be aligned before the operation)

void CDrawEightBppBitmapCommon::WriteLineOR(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	register TInt pixelPtrInc = LogicalPixelAddressIncrement();

	TUint8* bufferPtr = reinterpret_cast <TUint8*> (aBuffer);

	const TUint8* bufferPtrLimit = bufferPtr + aLength;

	if(iScalingOff)

		{

		while(bufferPtr < bufferPtrLimit)

			{

			*pixelPtr |= *bufferPtr++;

			pixelPtr += pixelPtrInc;

			}

		}

	else

		{

		const TUint8* bitsStart = reinterpret_cast <const TUint8*> (iBits);

		const TUint8* bitsEnd = bitsStart + iLongWidth * iSize.iHeight;

		while(bufferPtr < bufferPtrLimit)

			{

			const TUint8* pixelRowPtrLimit = bitsStart + (aY + 1) * iLongWidth;

			ORPixels(pixelPtr, *bufferPtr++, pixelRowPtrLimit, bitsStart, bitsEnd);

			pixelPtr += pixelPtrInc;

			IncScaledY(aY);

			}

		}

	}

//CDrawEightBppBitmapCommon::WriteRgbMulti() called from CDrawBitmap::WriteRgbMulti()

//aX and aY - physical coordinates

//aLength and aRows - physical length and rows

void CDrawEightBppBitmapCommon::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aRows,

											  TUint8 aPixel)

	{

	register TInt longWidth = iLongWidth;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8* pixelRowPtrLimit = pixelPtr + aRows * longWidth;

	register const TUint8* bitsEnd = reinterpret_cast <const TUint8*> (iBits) + iLongWidth * iSize.iHeight;

	if(pixelRowPtrLimit >= bitsEnd)

		{

		pixelRowPtrLimit = bitsEnd;

		}

	while (pixelPtr < pixelRowPtrLimit)

		{

		Mem::Fill(pixelPtr,aLength,aPixel);

		pixelPtr += longWidth;

		}

	}

//CDrawEightBppBitmapCommon::WriteRgbMultiXOR() called from CDrawBitmap::WriteRgbMulti()

//aX and aY - physical coordinates

//aLength and aRows - physical length and rows

void CDrawEightBppBitmapCommon::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aRows,

												 TUint8 aPixel)

	{

	register TInt longWidth = iLongWidth;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	TUint8* pixelPtrLimit = pixelPtr + aLength;

	const TUint8* pixelRowPtrLimit = pixelPtr + aRows * longWidth;

	register const TUint8* bitsEnd = reinterpret_cast <const TUint8*> (iBits) + iLongWidth * iSize.iHeight;

	if(pixelRowPtrLimit >= bitsEnd)

		{

		pixelRowPtrLimit = bitsEnd;

		}

	while (pixelPtr < pixelRowPtrLimit)

		{

		TUint8* tempPixelPtr = pixelPtr;

		while (tempPixelPtr < pixelPtrLimit)

			*tempPixelPtr++ ^= aPixel;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

//CDrawEightBppBitmapCommon::WriteRgbMultiAND() called from CDrawBitmap::WriteRgbMulti()

//aX and aY - physical coordinates

//aLength and aRows - physical length and rows

void CDrawEightBppBitmapCommon::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aRows,

												 TUint8 aPixel)

	{

	register TInt longWidth = iLongWidth;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8* pixelPtrLimit = pixelPtr + aLength;

	const TUint8* pixelRowPtrLimit = pixelPtr + aRows * longWidth;

	register const TUint8* bitsEnd = reinterpret_cast <const TUint8*> (iBits) + iLongWidth * iSize.iHeight;

	if(pixelRowPtrLimit >= bitsEnd)

		{

		pixelRowPtrLimit = bitsEnd;

		}

	while (pixelPtr < pixelRowPtrLimit)

		{

		TUint8* tempPixelPtr = pixelPtr;

		while (tempPixelPtr < pixelPtrLimit)

			*tempPixelPtr++ &= aPixel;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

//CDrawEightBppBitmapCommon::WriteRgbMultiOR() called from CDrawBitmap::WriteRgbMulti()

//aX and aY - physical coordinates

//aLength and aRows - physical length and rows

void CDrawEightBppBitmapCommon::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aRows,TUint8 aPixel)

	{

	register TInt longWidth = iLongWidth;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	TUint8* pixelPtrLimit = pixelPtr + aLength;

	const TUint8* pixelRowPtrLimit = pixelPtr + aRows * longWidth;

	register const TUint8* bitsEnd = reinterpret_cast <const TUint8*> (iBits) + iLongWidth * iSize.iHeight;

	if(pixelRowPtrLimit >= bitsEnd)

		{

		pixelRowPtrLimit = bitsEnd;

		}

	while (pixelPtr < pixelRowPtrLimit)

		{

		TUint8* tempPixelPtr = pixelPtr;

		while (tempPixelPtr < pixelPtrLimit)

			*tempPixelPtr++ |= aPixel;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

/**

Implementation for CFbsDrawDevice::GetInterface().

Retrieves a pointer to a specified interface of CFbsDrawDevice implementation.

@param aInterfaceId Interface identifier of the interface to be retrieved.

@param aInterface Address of variable that retrieves the specified interface.

@return KErrNone If the interface is supported, KErrNotSupported otherwise.

*/

TInt CDrawEightBppBitmapCommon::GetInterface(TInt aInterfaceId, TAny*& aInterface)

	{

	aInterface = NULL;

	TInt ret = KErrNotSupported;

	if (aInterfaceId == KFastBlit2InterfaceID)

		{

		aInterface = static_cast<MFastBlit2*>(this);

		ret = KErrNone;

		}

	else 

		return CDrawBitmap::GetInterface(aInterfaceId, aInterface);

	return ret;

	}

/**

CDrawEightBppBitmapCommon::WriteBitmapBlock() implementation.

@internalTechnology

@see MFastBlit2::WriteBitmapBlock()

*/

TInt CDrawEightBppBitmapCommon::WriteBitmapBlock(const TPoint& aDest,

									CFbsDrawDevice* aSrcDrawDevice,

									const TRect& aSrcRect)

	{

	__ASSERT_DEBUG(aSrcDrawDevice && ((aSrcDrawDevice->DisplayMode()==EColor256) || (aSrcDrawDevice->DisplayMode()==EGray256)), Panic(EScreenDriverPanicInvalidParameter));

	TAny* interface=NULL;

	TInt ret = aSrcDrawDevice->GetInterface(KFastBlit2InterfaceID, interface);

	if (ret != KErrNone)

		{

		return KErrNotSupported;

		}

	TAny* interface1=NULL;

	ret = aSrcDrawDevice->GetInterface(KScalingSettingsInterfaceID, interface1);

	if(ret != KErrNone || (interface1 && !reinterpret_cast<MScalingSettings*>(interface1)->IsScalingOff()))

		{

		return KErrNotSupported;

		}

	ret = aSrcDrawDevice->GetInterface(KOrientationInterfaceID, interface1);

	if(ret != KErrNone || (interface1 && reinterpret_cast<MDrawDeviceOrientation*>(interface1)->Orientation() != 0))

		{

		return KErrNotSupported;

		}

	ret = aSrcDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, interface1);

	if(ret != KErrNone)

		{

		return KErrNotSupported;

		}

	if(interface1)

		{

	 	TPoint pt;

	 	reinterpret_cast<MDrawDeviceOrigin*>(interface1)->Get(pt);

	 	if(pt.iX != 0 || pt.iY != 0)

	 		{

			return KErrNotSupported;

	 		}

		}

	const TUint32* srcBase = reinterpret_cast<MFastBlit2*>(interface)->Bits();

	__ASSERT_DEBUG(srcBase!=NULL, Panic(EScreenDriverPanicInvalidParameter));

	TInt srcStride = aSrcDrawDevice->ScanLineBytes();  

	__ASSERT_DEBUG((srcStride&3)==0, Panic(EScreenDriverPanicInvalidParameter));  // stride is assumed to be a multiple of 4

	TSize srcSize = aSrcDrawDevice->SizeInPixels();

	return WriteBitmapBlock(aDest, srcBase, srcStride, srcSize, aSrcRect);

	}

/**

CDrawEightBppBitmapCommon::WriteBitmapBlock() implementation.

@internalTechnology

@see MFastBlit2::WriteBitmapBlock()

*/													

TInt CDrawEightBppBitmapCommon::WriteBitmapBlock(const TPoint& aDest,

									const TUint32* aSrcBase,

									TInt aSrcStride,

									const TSize& aSrcSize,

									const TRect& aSrcRect)

	{

	__ASSERT_DEBUG(aSrcBase, Panic(EScreenDriverPanicInvalidParameter));

	__ASSERT_DEBUG((aSrcStride&3)==0, Panic(EScreenDriverPanicInvalidParameter));

	__ASSERT_DEBUG(iBits, Panic(EScreenDriverPanicInvalidPointer));

	if (iShadowMode!=NULL ||

    	(iUserDispMode!=NULL && iUserDispMode!=iDispMode) ||

    	iOrientation!=EOrientationNormal ||

		!IsScalingOff() ||

		!iOriginIsZero)

		{

		return KErrNotSupported;

		}

	__ASSERT_DEBUG(aSrcRect.iTl.iX >= 0, Panic(EScreenDriverPanicOutOfBounds)); 

	__ASSERT_DEBUG(aSrcRect.iTl.iY >= 0, Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(aSrcRect.iBr.iX <= aSrcSize.iWidth,  Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(aSrcRect.iBr.iY <= aSrcSize.iHeight, Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(aDest.iX >= 0, Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(aDest.iY >= 0, Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG((aDest.iX + aSrcRect.Width())  <= SizeInPixels().iWidth,  Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG((aDest.iY + aSrcRect.Height()) <= SizeInPixels().iHeight, Panic(EScreenDriverPanicOutOfBounds));

	const TInt srcStride8 = aSrcStride;

	const TInt dstStride8 = iScanLineWords << 2;

	if (aSrcSize.iWidth == aSrcRect.Width() &&

		aSrcSize.iWidth == SizeInPixels().iWidth &&

		srcStride8 == dstStride8)

		{

		// Optimum case - one memcpy

		__ASSERT_DEBUG(aSrcRect.iTl.iX==0 && aDest.iX==0, Panic(EScreenDriverPanicInvalidParameter));  // this is implied by the above conditions

		const TUint32* srcPtr = aSrcBase + (iScanLineWords * aSrcRect.iTl.iY);

		TUint32* dstPtr       = iBits    + (iScanLineWords * aDest.iY);

		const TInt length = aSrcStride * aSrcRect.Height();

		Mem::Move(dstPtr, srcPtr, length);

		return KErrNone;

		}

	// Sub-optimal case - one memcpy per line

	const TUint8* srcPtr = (TUint8*)aSrcBase + (srcStride8 * aSrcRect.iTl.iY) + aSrcRect.iTl.iX;

	TUint8* dstPtr       = (TUint8*)iBits    + (dstStride8 * aDest.iY       ) + aDest.iX;

	const TInt length = aSrcRect.Width();

	TInt lines = aSrcRect.Height();

	while (lines--)

		{

		Mem::Copy(dstPtr, srcPtr, length);

		srcPtr += srcStride8;

		dstPtr += dstStride8;

		}

	return KErrNone;

	}

/**

CDrawEightBppBitmapCommon::Bits() implementation.

@internalTechnology

@see MFastBlit2::Bits()

*/

const TUint32* CDrawEightBppBitmapCommon::Bits() const

	{

	return iBits;

}