// Copyright (c) 2004-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 <graphics/lookuptable.h>

 #include <graphics/blendingalgorithms.h>

 #include "BMDRAW.H"

 #include "BitDrawInterfaceId.h"

 FORCEINLINE void BlendFromRBandG(TUint32 *aPixelPtr, TUint32 aSrcRB, TUint32 aSrcG, TUint32 aSrcAlpha, TUint32 aMaskX2)

 	{

 	const TUint32 d = *aPixelPtr;

 	const TUint32 d_rb = d & 0x00FF00FF;

 	const TUint32 rb = ((((aSrcAlpha * ((0x01000100 + aSrcRB) - d_rb)) >> 8) + d_rb) - aMaskX2) & 0x00FF00FF;

 	const TInt d_g = (d & 0xFF00) >> 8;

 	const TInt g = ((aSrcAlpha * (aSrcG - d_g)) >> 8) + d_g;

 	*aPixelPtr = rb | (g<<8) | 0xff000000;

 	}

 /**Initializes iSize, iDrawRect, iLongWidth, iScanLineBytes, 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 CDrawThirtyTwoBppBitmapCommon::SetSize(const TSize& aSize)

 	{

 	CDrawBitmap::SetSize(aSize);

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

 	iLongWidth = iSize.iWidth;

 	iScanLineWords = iSize.iWidth;

 	}

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

 	{

 	iBits = NULL;

 	CDrawBitmap::SetSize(aSize);

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

 	if (aStride & 3)

 		return KErrArgument;

 	iLongWidth = aStride >> 2;

 	if (iLongWidth < aSize.iWidth)

 		return KErrArgument;

 	iScanLineWords = iLongWidth;

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

 	if(size < 0)

 		return KErrArgument;

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

 	if (iScanLineBuffer == NULL)

 		return KErrNoMemory;

 	return KErrNone;

 	}

 void CDrawThirtyTwoBppBitmapCommon::Shadow(TRgb& aColor)

 	{

 	TUint32 value = aColor.Internal();

 	const TInt alpha = value >> 24;

 	if (iShadowMode & EFade)

 		{

 #if defined(SYMBIAN_USE_FAST_FADING)

 		value = ((value >> 1) & ~0x00808080) + (SYMBIAN_USE_FAST_FADING);

 #else		

 		const TInt wordFadeMapOffset = ((iFadeMapOffset & 0xff) << 16) | (iFadeMapOffset & 0xff);		

 		const TInt rb = ((((value & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

 	  	const TInt g = ((((value & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset) << 8;

 		value = rb | g;

 #endif		

 		}

 	if (iShadowMode & EShadow)

 		{

 		const TInt r = (value & 0x00c00000) ? ((value & 0x00ff0000)-0x00400000) : 0;

 		const TInt g = (value & 0x0000c000) ? ((value & 0x0000ff00)-0x00004000) : 0;

 		const TInt b = (value & 0x000000c0) ? ((value & 0x000000ff)-0x00000040) : 0;

 		value = r | g | b;

 		}

 	aColor = TRgb(value,alpha);

 	}

 void CDrawThirtyTwoBppBitmapCommon::Shadow(TUint32& aColor)

 	{

 	// aColor is in the format indicated by ScanLineDisplayMode(), which we

 	// assume is EColor16MAP here. If not, this function must be overridden.

 	const TInt alpha = (aColor >> 24) + 1;

 	TUint32 value = aColor & 0x00ffffff;

 	if (iShadowMode & EFade)

 		{

 #if defined(SYMBIAN_USE_FAST_FADING)

 		const TUint32 fast_fade_offset = NonPMA2PMAPixel((aColor & 0xff000000) | SYMBIAN_USE_FAST_FADING) & 0x00ffffff;

 		value = ((value >> 1) & ~0x00808080) + (fast_fade_offset);

 #else

 		const TInt fadeMapOffset = ((alpha * iFadeMapOffset) >> 8) & 0xff;

 		const TInt wordFadeMapOffset = ((fadeMapOffset) << 16) | (fadeMapOffset);

 		const TInt rb = ((((value & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

 	  	const TInt g = ((((value & 0x0000ff00) * iFadeMapFactor) >> 16) + fadeMapOffset) << 8;

 		value = rb | g;

 #endif

 		}

 	if (iShadowMode & EShadow)

 		{

 		const TInt uLimit = ((0x40) * alpha) >> 8;

 		TInt r = (value >> 16) & 0xff;

 		r = (r > uLimit) ? (r-uLimit) : 0;

 		TInt g = (value >> 8) & 0xff;

 		g = (g > uLimit) ? (g - uLimit) : 0;

 		TInt b = value & 0xff;

 		b = (b > uLimit) ? (b - uLimit) : 0;

 		value = (r << 16) | (g << 8) | b;

 		}

 	// alpha is unchanged.

 	aColor = (aColor & 0xff000000) | value;

 	}

 TUint8 CDrawThirtyTwoBppBitmapCommon::ShadowAndFade(TInt aComponent)

 	{

 	if (iShadowMode & EFade)

 		aComponent = FadeGray(aComponent);

 	if (iShadowMode & EShadow)

 		aComponent = ShadowComponent(aComponent);

 	return TUint8(aComponent);

 	}

 TUint8 CDrawThirtyTwoBppBitmapCommon::ShadowComponent(TInt aRgbComponent)

 	{

 	return TUint8(Max(0,aRgbComponent-0x40));

 	}

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

 	{

 	__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicOutOfBounds));

 	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

 	TUint32* limit = aBuffer + aLength;

 	while (aBuffer < limit)

 		{

 		*aBuffer++ ^= 0x00ffffff;

 		}

 	}

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

 	{

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

 	if (iOrientation == EOrientationNormal)

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

 	else

 		{

 		const TInt pixelPtrInc = PixelAddressIncrement();

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

 		const TUint32* bufferPtrLimit = bufferPtr + aLength;

 		while (bufferPtr < bufferPtrLimit)

 			{

 			*bufferPtr++ = *pixelPtr;

 			pixelPtr += pixelPtrInc;

 			}

 		}

 	}

 TRgb CDrawThirtyTwoBppBitmapCommon::ReadRgbNormal(TInt aX,TInt aY) const

 	{

 	return RgbColor(*PixelAddress(aX,aY));

 	}

 void CDrawThirtyTwoBppBitmapCommon::ShadowArea(const TRect& aRect)

 	{

 	const TRect rect(DeOrientate(aRect));

 	__ASSERT_DEBUG(rect.iTl.iX>=0 && rect.iBr.iX<=iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));

 	__ASSERT_DEBUG(rect.iTl.iY>=0 && rect.iBr.iY<=iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));

 	TUint32* pixelPtr = PixelAddress(rect.iTl.iX,rect.iTl.iY);

 	TUint32* pixelRowPtrLimit = pixelPtr + (rect.Height() * iScanLineWords);

 	TUint32* pixelRowPtr = pixelPtr;

 	TUint32* pixelPtrLimit = pixelPtr + rect.Width();

 	if (iShadowMode & EFade)

 		{

 #if !defined(SYMBIAN_USE_FAST_FADING)		

 		const TInt wordFadeMapOffset = ((iFadeMapOffset & 0xff) << 16) | (iFadeMapOffset & 0xff);

 #endif

 		while (pixelRowPtr < pixelRowPtrLimit)

 			{

 			TUint32* tempPixelPtr = pixelRowPtr;

 			while (tempPixelPtr < pixelPtrLimit)

 				{

 #if defined(SYMBIAN_USE_FAST_FADING)

 				*tempPixelPtr++ = 0xff000000 | ((((*tempPixelPtr) >> 1) & ~0x00808080) + (SYMBIAN_USE_FAST_FADING));

 #else

 				const TUint32 color = *tempPixelPtr;

 				const TInt rb = ((((color & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

 	  			const TInt g = ((((color & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset) << 8;

 				*tempPixelPtr++ = 0xff000000 | rb | g;

 #endif				

 				}

 			pixelRowPtr += iScanLineWords;

 			pixelPtrLimit += iScanLineWords;

 			}

 		}

 	if (iShadowMode & EShadow)

 		{

 		pixelRowPtr = pixelPtr;

 		pixelPtrLimit = pixelPtr + rect.Width();		

 		while (pixelRowPtr < pixelRowPtrLimit)

 			{

 			TUint32* tempPixelPtr = pixelRowPtr;

 			while (tempPixelPtr < pixelPtrLimit)

 				{

 				const TUint32 color = *tempPixelPtr;

 				const TInt r = (color & 0x00c00000) ? ((color & 0x00ff0000)-0x00400000) : 0;

 				const TInt g = (color & 0x0000c000) ? ((color & 0x0000ff00)-0x00004000) : 0;

 				const TInt b = (color & 0x000000c0) ? ((color & 0x000000ff)-0x00000040) : 0;

 				*tempPixelPtr++	= 0xff000000 | r | g | b;

 				}

 			pixelRowPtr += iScanLineWords;

 			pixelPtrLimit += iScanLineWords;

 			}

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::ShadowBuffer(TInt aLength,TUint32* aBuffer)

 	{

 	__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicZeroLength));

 	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

 	TUint32* limit = aBuffer + aLength;

 	while (aBuffer < limit)

 		Shadow(*aBuffer++);

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgb(TInt aX,TInt aY,TRgb aColor)

 	{

 	TUint8* componentPtr = reinterpret_cast <TUint8*> (PixelAddress(aX,aY));

 	const TInt sourceAlpha = aColor.Alpha();

 	if (sourceAlpha==0)

 		return;

 	if(sourceAlpha != 0xff)

 		{

 		aColor = AlphaBlend(aColor.Red(), aColor.Green(), aColor.Blue(), TRgb(componentPtr[2], componentPtr[1], componentPtr[0]), sourceAlpha);

 		}

 	componentPtr[0] = TUint8(aColor.Blue());

 	componentPtr[1] = TUint8(aColor.Green());

 	componentPtr[2] = TUint8(aColor.Red());

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor)

 	{

 	const TInt sourceAlpha = aColor.Alpha();

 	if(sourceAlpha == 0)

 		return;

 	DeOrientate(aX,aY);

 	TInt pixelInc;

 	TInt rowInc;

 	switch(iOrientation)

 		{

 		case EOrientationNormal:

 			{

 			pixelInc = 1;

 			rowInc = iScanLineWords;

 			break;

 			}

 		case EOrientationRotated90:

 			{

 			pixelInc = iScanLineWords;

 			rowInc = -1;

 			break;

 			}

 		case EOrientationRotated180:

 			{

 			pixelInc = -1;

 			rowInc = -iScanLineWords;

 			break;

 			}

 		default: // EOrientationRotated270

 			{

 			pixelInc = -iScanLineWords;

 			rowInc = 1;

 			}

 		}

 	const TUint32* dataLimit = aBuffer + aHeight;

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

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	if(sourceAlpha == 255) //we split code on two parts because of performance reasons

 		{

 		TInt color = Color(aColor);

 		while (aBuffer < dataLimit)

 			{

 			TUint32 dataWord = *aBuffer++;

 			TUint32 dataMask = 1;

 			TUint32* tempPixelPtr = pixelPtr;

 			while (dataMask != dataMaskLimit)

 				{

 				if(dataWord & dataMask)

 					{

 					*tempPixelPtr = color;

 					}

 				tempPixelPtr += pixelInc;

 				dataMask <<= 1;

 				}

 			pixelPtr += rowInc;

 			}

 		}

 	else //sourceAlpha != 255

 		{

 		const TUint32 sourceInternal=aColor.Internal();

 		const TUint32 s_rb = sourceInternal & 0x00FF00FF;

 		const TUint32 s_g = (sourceInternal & 0xFF00) >> 8;

 		const TUint32 mask2 = sourceAlpha | (sourceAlpha << 16);

 		while (aBuffer < dataLimit)

 			{

 			TUint32 dataWord = *aBuffer++;

 			TUint32 dataMask = 1;

 			TUint32* tempPixelPtr = pixelPtr;

 			while (dataMask != dataMaskLimit)

 				{

 				if (dataWord & dataMask)

 					{

 					BlendFromRBandG(tempPixelPtr,s_rb,s_g,sourceAlpha,mask2);

 					}

 				tempPixelPtr += pixelInc;

 				dataMask <<= 1;

 				}

 			pixelPtr += rowInc;

 			}

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteBinaryOp(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)

 	{

 	if (aLength <= 0)

 		return;

 	DeOrientate(aX,aY);

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TUint32* dataPtrLimit = aBuffer + aHeight;

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

 	TInt pixelInc;

 	TInt rowInc;

 	if (iOrientation == EOrientationNormal)

 		{

 		pixelInc = 1;

 		rowInc = iScanLineWords;

 		}

 	else if (iOrientation == EOrientationRotated90)

 		{

 		pixelInc = iScanLineWords;

 		rowInc = -1;

 		}

 	else if (iOrientation == EOrientationRotated180)

 		{

 		pixelInc = -1;

 		rowInc = -iScanLineWords;

 		}

 	else // EOrientationRotated270

 		{

 		pixelInc = -iScanLineWords;

 		rowInc = 1;

 		}

 	TInt color = Color(aColor);// & 0x00FFFFFF;

 	if (color != 0)

 		{

 		while (aBuffer < dataPtrLimit)

 			{

 			TUint32 dataWord = *aBuffer++;

 			TUint32 dataMask = 1;

 			TUint32* tempPixelPtr = pixelPtr;

 			while (dataMask != dataMaskLimit)

 				{

 				if(dataWord & dataMask)

 					{

 					if(aDrawMode==CGraphicsContext::EDrawModeXOR)

 						{

 						*tempPixelPtr ^= color;

 						}

 					else if(aDrawMode==CGraphicsContext::EDrawModeAND)

 						{

 						*tempPixelPtr &= color;

 						}

 					else if(aDrawMode==CGraphicsContext::EDrawModeOR)

 						{

 						*tempPixelPtr |= color;

 						}

 					}

 				tempPixelPtr += pixelInc;

 				dataMask <<= 1;

 				}

 			pixelPtr += rowInc;

 			}

 		}

 	else if (aDrawMode == CGraphicsContext::EDrawModeAND)

 		{

 		while (aBuffer < dataPtrLimit)

 			{

 			TUint32 dataWord = *aBuffer++;

 			TUint32 dataMask = 1;

 			TUint32* tempPixelPtr = pixelPtr;

 			while (dataMask != dataMaskLimit)

 				{

 				if(dataWord & dataMask)

 					{

 					*tempPixelPtr = 0;

 					}

 				tempPixelPtr += pixelInc;

 				dataMask <<= 1;

 				}

 			pixelPtr += rowInc;

 			}

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aHeight,TRgb aColor,TBool aUp)

 	{

 	const TInt sourceAlpha = aColor.Alpha();

 	if(sourceAlpha == 0)

 		return;

 	DeOrientate(aX,aY);

 	TInt scanlineWordLength;

 	if (iOrientation == EOrientationNormal)

 		scanlineWordLength = iScanLineWords;

 	else if (iOrientation == EOrientationRotated90)

 		scanlineWordLength = -1;

 	else if (iOrientation == EOrientationRotated180)

 		scanlineWordLength = -iScanLineWords;

 	else // EOrientationRotated270

 		scanlineWordLength = 1;

 	if (aUp)

 		scanlineWordLength = -scanlineWordLength;

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TUint32* pixelPtrLimit = pixelPtr + (aHeight * scanlineWordLength);

 	TUint32 dataWord = *aBuffer;

 	TUint32 dataMask = 1;

 	if(sourceAlpha == 255) //we split code on two parts because of performance reasons

 		{

 		TInt color = Color(aColor);

 		while(pixelPtr != pixelPtrLimit)

 			{

 			if(!dataMask)

 				{

 				dataMask = 1;

 				aBuffer++;

 				dataWord = *aBuffer;

 				}

 			if(dataWord & dataMask)

 				{

 				*pixelPtr = color;

 				}

 			dataMask <<= 1;

 			pixelPtr += scanlineWordLength;

 			}

 		}

 	else //sourceAlpha != 255

 		{

 		const TUint32 sourceInternal=aColor.Internal();

 		const TUint32 s_rb = sourceInternal & 0x00FF00FF;

 		const TUint32 s_g = (sourceInternal & 0xFF00) >> 8;

 		const TUint32 mask2 = sourceAlpha | (sourceAlpha << 16);

 		while(pixelPtr != pixelPtrLimit)

 			{

 			if(!dataMask)

 				{

 				dataMask = 1;

 				aBuffer++;

 				dataWord = *aBuffer;

 				}

 			if(dataWord & dataMask)

 				{

 				BlendFromRBandG(pixelPtr, s_rb, s_g, sourceAlpha, mask2);

 				}

 			dataMask <<= 1;

 			pixelPtr += scanlineWordLength;

 			}

 		}

 	}

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

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	if (iOrientation == EOrientationNormal)

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

 	else

 		{

 		const TInt pixelPtrInc = PixelAddressIncrement();

 		TUint32* bufferPtrLimit = aBuffer + aLength;

 		while (aBuffer < bufferPtrLimit)

 			{

 			*pixelPtr = *aBuffer++;

 			pixelPtr += pixelPtrInc;

 			}

 		}

 	}

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

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TInt pixelPtrInc = PixelAddressIncrement();

 	TUint32* bufferPtrLimit = aBuffer + aLength;

 	while (aBuffer < bufferPtrLimit)

 		{

 		*pixelPtr ^= *aBuffer++;

 		pixelPtr += pixelPtrInc;

 		}

 	}

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

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TInt pixelPtrInc = PixelAddressIncrement();

 	TUint32* bufferPtrLimit = aBuffer + aLength;

 	while (aBuffer < bufferPtrLimit)

 		{

 		*pixelPtr &= *aBuffer++;

 		pixelPtr += pixelPtrInc;

 		}

 	}

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

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TInt pixelPtrInc = PixelAddressIncrement();

 	TUint32* bufferPtrLimit = aBuffer + aLength;

 	while (aBuffer < bufferPtrLimit)

 		{

 		*pixelPtr |= *aBuffer++;

 		pixelPtr += pixelPtrInc;

 		}

 	}

 /**

 MAlphaBlend::WriteRgbAlphaLine() implementation.

 @see MAlphaBlend::WriteRgbAlphaLine()

 */

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbAlphaLine(TInt aX, TInt aY, TInt aLength,

                                                   const TUint8* aRgbBuffer,

                                                   const TUint8* aMaskBuffer,

                                                   MAlphaBlend::TShadowing aShadowing,

                                                   CGraphicsContext::TDrawMode /*aDrawMode*/)

     {

 	DeOrientate(aX,aY);

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TInt pixelPtrInc = PixelAddressIncrement();

 	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

 	while (aMaskBuffer < maskBufferPtrLimit)

 		{

 		TRgb srcColor(aRgbBuffer[2],aRgbBuffer[1],aRgbBuffer[0]);// !! we don't have any alpha information for the source, so assume opaque

 		if(aMaskBuffer[0])

 			{

 			if(aShadowing == MAlphaBlend::EShdwBefore)

 				{

 				Shadow(srcColor);

 				}

 			TUint8* componentPtr = reinterpret_cast <TUint8*> (pixelPtr);

 			if(aMaskBuffer[0] != 0xff)

 				{

 				srcColor = AlphaBlend(srcColor.Red(), srcColor.Green(), srcColor.Blue(), TRgb(componentPtr[2], componentPtr[1], componentPtr[0]), aMaskBuffer[0]);

 				}

 			if(aShadowing == MAlphaBlend::EShdwAfter)

 				{

 				Shadow(srcColor);

 				}

 			MapColorToUserDisplayMode(srcColor);

 			componentPtr[0] = TUint8(srcColor.Blue());

 			componentPtr[1] = TUint8(srcColor.Green());

 			componentPtr[2] = TUint8(srcColor.Red());

 			}

 		pixelPtr += pixelPtrInc;

 		aRgbBuffer += 4;

 		aMaskBuffer++;

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	TUint32* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineWords);

 	TInt color = Color(aColor);

 	while (pixelPtr < pixelRowPtrLimit)

 		{

 		MemFillTUint32(pixelPtr, aLength, color);

 		pixelPtr += iScanLineWords;

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	TUint32* pixelPtrLimit = pixelPtr + aLength;

 	TUint32* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineWords);

 	TInt color = Color(aColor);

 	while (pixelPtr < pixelRowPtrLimit)

 		{

 		for (TUint32* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

 			{

 			*tempPixelPtr ^= color;

 			}

 		pixelPtr += iScanLineWords;

 		pixelPtrLimit += iScanLineWords;

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	TUint32* pixelPtrLimit = pixelPtr + aLength;

 	TUint32* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineWords);

 	TInt color = Color(aColor);

 	while (pixelPtr < pixelRowPtrLimit)

 		{

 		for (TUint32* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

 			{

 			*tempPixelPtr &= color;

 			}

 		pixelPtr += iScanLineWords;

 		pixelPtrLimit += iScanLineWords;

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)

 	{

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	TUint32* pixelPtrLimit = pixelPtr + aLength;

 	TUint32* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineWords);

 	TInt color = Color(aColor);

 	while (pixelPtr < pixelRowPtrLimit)

 		{

 		for (TUint32* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

 			{

 			*tempPixelPtr |= color;

 			}

 		pixelPtr += iScanLineWords;

 		pixelPtrLimit += iScanLineWords;

 		}

 	}

 inline TUint32 OptimizedBlend32(TInt aPrimaryRed,TInt aPrimaryGreen,TInt aPrimaryBlue,TUint32 aSecondary,TUint8 aAlphaValue)

 	{

  	__ASSERT_DEBUG(!(aPrimaryRed>>8) && !(aPrimaryGreen>>8) && !(aPrimaryBlue>>8) && !(aAlphaValue>>8),

 					Panic(EScreenDriverPanicAlphaBlendInvariant));

  	if(aAlphaValue == 0xff)

 		{

 		return (aPrimaryBlue + (aPrimaryGreen<<8) + (aPrimaryRed<<16)) | 0xff000000;

  		}

  	else

  		{

  		const TUint32 alphaValue = (aAlphaValue << 8) + aAlphaValue;

  		const TInt r2 = (aSecondary & 0x00ff0000) >> 16;

  		const TInt g2 = (aSecondary & 0x0000ff00) >> 8;

  		const TInt b2 = aSecondary & 0x000000ff;

  		const TInt r3 = ((alphaValue * (aPrimaryRed   - r2)) >> 16) + r2;

 		const TInt g3 = ((alphaValue * (aPrimaryGreen - g2)) >> 16) + g2;

 		const TInt b3 = ((alphaValue * (aPrimaryBlue  - b2)) >> 16) + b2;

 		return (b3 & 0xFF) | ((g3<<8) & 0xFF00) | ((r3<<16) & 0xFF0000) | 0xFF000000;

  		}

  	}

 void CDrawThirtyTwoBppBitmapCommon::WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,TRgb aColor,const TUint8* aMaskBuffer)

 	{

 	const TUint32 sourceAlpha = aColor.Alpha();

 	if (sourceAlpha==0 || aLength<=0)

 		return;

 	DeOrientate(aX,aY);

 	TUint32* pixelPtr = PixelAddress(aX,aY);

 	const TInt pixelPtrInc = PixelAddressIncrement();

 	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

 	if (iShadowMode)

 		Shadow(aColor);

 	const TUint32 sourceInternal=aColor.Internal();

 	const TUint32 s_rb = sourceInternal & 0x00FF00FF;

 	const TUint32 s_g = (sourceInternal & 0xFF00) >> 8;

 	if (sourceAlpha==0xFF)

 		{

 		while (aMaskBuffer < maskBufferPtrLimit)

 			{

 			const TUint32 maskAlpha=*aMaskBuffer;

 			if (maskAlpha)

 				{

 				if (maskAlpha==0xFF)

 					*pixelPtr = sourceInternal;

 				else

 					BlendFromRBandG(pixelPtr,s_rb,s_g,maskAlpha,maskAlpha|(maskAlpha<<16));

 				}

 			pixelPtr += pixelPtrInc;

 			aMaskBuffer++;

 			}

 		}

 	else

 		{

 		while (aMaskBuffer < maskBufferPtrLimit)

 			{

 			const TUint32 maskAlpha=*aMaskBuffer;

 			if (maskAlpha)

 				{

 				TUint blendAlpha = sourceAlpha;

 				if (maskAlpha!=0xFF)

 					blendAlpha=((maskAlpha+1) * sourceAlpha)>>8;

 				BlendFromRBandG(pixelPtr,s_rb,s_g,blendAlpha,blendAlpha|(blendAlpha<<16));

 				}

 			pixelPtr += pixelPtrInc;

 			aMaskBuffer++;

 			}

 		}

 	}

 void CDrawThirtyTwoBppBitmapCommon::MapColorToUserDisplayMode(TRgb& aColor)

 	{

 	const TInt alpha = aColor.Alpha();

 	switch (iUserDispMode)

 		{

 	case EGray2:

 		aColor = TRgb::_Gray2(aColor._Gray2());

 		break;

 	case EGray4:

 		aColor = TRgb::_Gray4(aColor._Gray4());

 		break;

 	case EGray16:

 		aColor = TRgb::_Gray16(aColor._Gray16());

 		break;

 	case EGray256:

 		aColor = TRgb::_Gray256(aColor._Gray256());

 		break;

 	case EColor16:

 		aColor = TRgb::Color16(aColor.Color16());

 		break;

 	case EColor256:

 		aColor = TRgb::Color256(aColor.Color256());

 		break;

 	case EColor4K:

 		aColor = TRgb::_Color4K(aColor._Color4K());

 		break;

 	case EColor64K:

 		aColor = TRgb::_Color64K(aColor._Color64K());

 		break;

 	default:

 		break;

 		}

 	aColor.SetAlpha(alpha);

 	}

 void CDrawThirtyTwoBppBitmapCommon::MapBufferToUserDisplayMode(TInt aLength,TUint32* aBuffer)

 	{

 	const TUint32* bufferLimit = aBuffer + aLength;

 	const TUint16* nTable = PtrTo16BitNormalisationTable();

 	TRgb color;

 	switch (iUserDispMode)

 		{

 	case EGray2:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Gray2(color._Gray2());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EGray4:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Gray4(color._Gray4());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EGray16:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Gray16(color._Gray16());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EGray256:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Gray256(color._Gray256());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EColor16:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::Color16(color.Color16());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EColor256:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::Color256(color.Color256());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EColor4K:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Color4K(color._Color4K());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	case EColor64K:

 		while (aBuffer < bufferLimit)

 			{

 			color.SetInternal(PMA2NonPMAPixel(*aBuffer, nTable));

 			color = TRgb::_Color64K(color._Color64K());

 			*aBuffer++ = color.Internal();

 			}

 		break;

 	default:

 		break;

 		}

 	}

 /**

 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 CDrawThirtyTwoBppBitmapCommon::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;

 	}

 /**

 CDrawThirtyTwoBppBitmapCommon::WriteBitmapBlock() implementation.

 @internalTechnology

 @see MFastBlit2::WriteBitmapBlock()

 */

 TInt CDrawThirtyTwoBppBitmapCommon::WriteBitmapBlock(const TPoint& aDest,

 									CFbsDrawDevice* aSrcDrawDevice,

 									const TRect& aSrcRect)

 	{

 	__ASSERT_DEBUG(aSrcDrawDevice && ((aSrcDrawDevice->DisplayMode()==EColor16MU) || (aSrcDrawDevice->DisplayMode()==EColor16MA) ||(aSrcDrawDevice->DisplayMode()==EColor16MAP)), 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);

 	}

 /**

 CDrawThirtyTwoBppBitmapCommon::WriteBitmapBlock() implementation.

 @internalTechnology

 @see MFastBlit2::WriteBitmapBlock()

 */													

 TInt CDrawThirtyTwoBppBitmapCommon::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 srcStrideWords=aSrcStride >> 2;

 	const TInt dstStrideWords=iScanLineWords;

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

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

 		srcStrideWords == dstStrideWords)

 		{

 		// 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 TUint32* srcPtr = aSrcBase + (srcStrideWords * aSrcRect.iTl.iY) + aSrcRect.iTl.iX;

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

 	const TInt length = aSrcRect.Width() << 2;

 	TInt lines = aSrcRect.Height();

 	while (lines--)

 		{

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

 		srcPtr+=srcStrideWords;

 		dstPtr+=dstStrideWords;

 		}

 	return KErrNone;

 	}

 /**

 CDrawThirtyTwoBppBitmapCommon::Bits() implementation.

 @internalTechnology

 @see MFastBlit2::Bits()

 */

 const TUint32* CDrawThirtyTwoBppBitmapCommon::Bits() const

 	{

 	return iBits;

 	}