// 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"

//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 CDrawTwentyFourBppBitmap::SetSize(const TSize& aSize) 

	{

	CDrawBitmap::SetSize(aSize);

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

	iScanLineBytes = (((iSize.iWidth * 3) + 11) / 12) * 12;

	iLongWidth = iScanLineBytes / 3;

	iScanLineWords = iScanLineBytes / 4;

	}

TInt CDrawTwentyFourBppBitmap::Construct(TSize aSize)

	{

	return Construct(aSize, (((aSize.iWidth * 3) + 11) / 12) * 12);

	}

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

	{

	iBits = NULL;

	iDispMode = EColor16M;

	CDrawBitmap::SetSize(aSize);

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

	if (aStride % 12)

		return KErrArgument;

	iScanLineBytes = aStride;

	iLongWidth = aStride / 3;

	if (iLongWidth < aSize.iWidth)

		return KErrArgument;

	iScanLineWords = aStride >> 2;

	TInt size = (((Max(aSize.iWidth,aSize.iHeight) * 3) + 11) / 12) * 12;

	if(size < 0)

		return KErrArgument;

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

	if (iScanLineBuffer == NULL)

		return KErrNoMemory;

	return KErrNone;

	}

inline TInt CDrawTwentyFourBppBitmap::PixelAddressIncrement() const

	{

	switch (iOrientation)

		{

		case EOrientationNormal:

			return 3;

		case EOrientationRotated90:

			return iScanLineBytes;

		case EOrientationRotated180:

			return -3;

		case EOrientationRotated270:

			return -iScanLineBytes;

		default:

			return 1;

		}

	}

inline void  CDrawTwentyFourBppBitmap::PixelAddressIncrement(TInt& aPixelInc,TInt& aRowInc) const

	{

	switch (iOrientation)

		{

		case EOrientationNormal:

			aPixelInc = 3;

			aRowInc = iScanLineBytes;

			break;

		case EOrientationRotated90:

			aPixelInc = iScanLineBytes;

			aRowInc = -3;

			break;

		case EOrientationRotated180:

			aPixelInc = -3;

			aRowInc = -iScanLineBytes;

			break;

		case EOrientationRotated270:

			aPixelInc = -iScanLineBytes;

			aRowInc = 3;

			break;

		default:

			aPixelInc = 1;

			aRowInc = 1;

		}

	}

void CDrawTwentyFourBppBitmap::FadeRgb(TInt& red,TInt& green,TInt& blue)

	{

  	blue = ((blue * iFadeMapFactor) >> 8)  + iFadeMapOffset;

  	green = ((green * iFadeMapFactor) >> 16) + iFadeMapOffset;

  	red = ((red * iFadeMapFactor) >> 8) + iFadeMapOffset; 

	}

void CDrawTwentyFourBppBitmap::Shadow(TRgb& aColor)

	{

	if (iShadowMode & EFade)

		aColor = CDrawBitmap::FadeRgb(aColor);

	if (iShadowMode & EShadow)

		{

		TInt r = ShadowComponentInl(aColor.Red());

		TInt g = ShadowComponentInl(aColor.Green());

		TInt b = ShadowComponentInl(aColor.Blue());

		aColor = TRgb(r,g,b);

		}

	}

void CDrawTwentyFourBppBitmap::Shadow(TInt& red,TInt& green,TInt& blue)

  	{

  	if (iShadowMode & EFade)

  		FadeRgb(red,green,blue);

  	if (iShadowMode & EShadow)

		{

  		red = ShadowComponentInl(red);

  		green = ShadowComponentInl(green);

  		blue = ShadowComponentInl(blue);

  		}

	}

TUint8 CDrawTwentyFourBppBitmap::ShadowAndFade(TInt aComponent)

	{

	if (iShadowMode & EFade)

		aComponent = FadeGray(aComponent);

	if (iShadowMode & EShadow)

		aComponent = ShadowComponentInl(aComponent);

	return TUint8(aComponent);

	}

TUint8 CDrawTwentyFourBppBitmap::ShadowComponentInl(TInt aRgbComponent)

	{

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

	}

TUint8 CDrawTwentyFourBppBitmap::ShadowComponent(TInt aRgbComponent)

	{

	return ShadowComponentInl(aRgbComponent);

	}

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

	{

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

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	TUint8* buffer = (TUint8*)aBuffer;

	TUint8* limit = buffer + (aLength * 3);

	while (buffer < limit)

		*buffer++ ^= 0xff;

	}

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

	{

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

	if (iOrientation == EOrientationNormal)

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

	else

		{

		const TInt pixelPtrInc = PixelAddressIncrement();

		TUint8* bufferPtr = STATIC_CAST(TUint8*,aBuffer);

		const TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);

		while (bufferPtr < bufferPtrLimit)

			{

			*bufferPtr++ = pixelPtr[0];

			*bufferPtr++ = pixelPtr[1];

			*bufferPtr++ = pixelPtr[2];

			pixelPtr += pixelPtrInc;

			}

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	return TRgb(pixelPtr[2],pixelPtr[1],pixelPtr[0]);

	}

void CDrawTwentyFourBppBitmap::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));

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

	TUint8* pixelRowPtrLimit = pixelPtr + (rect.Height() * iScanLineBytes);

	if (iShadowMode & EFade)

		{

		TUint8* pixelRowPtr = pixelPtr;

		TUint8* pixelPtrLimit = pixelPtr + (rect.Width() * 3);

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint8* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

				*tempPixelPtr = FadeGray(*tempPixelPtr);

				++tempPixelPtr;

				}

			pixelRowPtr += iScanLineBytes;

			pixelPtrLimit += iScanLineBytes;

			}

		}

	if (iShadowMode & EShadow)

		{

		TUint8* pixelRowPtr = pixelPtr;

		TUint8* pixelPtrLimit = pixelPtr + (rect.Width() * 3);

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint8* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

				*tempPixelPtr = ShadowComponent(*tempPixelPtr);

				++tempPixelPtr;

				}

			pixelRowPtr += iScanLineBytes;

			pixelPtrLimit += iScanLineBytes;

			}

		}

	}

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

	{

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

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	TUint8* limit = ((TUint8*)aBuffer) + (aLength * 3);

	if (iShadowMode & EFade)

		{

		TUint8* buffer = (TUint8*)aBuffer;

		while (buffer < limit)

			{

			*buffer = FadeGray(*buffer);

			++buffer;

			}

		}

	if (iShadowMode & EShadow)

		{

		TUint8* buffer = (TUint8*)aBuffer;

		while (buffer < limit)

			{

			*buffer = ShadowComponent(*buffer);

			++buffer;

			}

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

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

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

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

	}

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

	{

	DeOrientate(aX,aY);

	TInt pixelInc;

	TInt rowInc;

	PixelAddressIncrement(pixelInc,rowInc);

	const TUint32* dataLimit = aBuffer + aHeight;

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

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8 r = (TUint8)aColor.Red();

	const TUint8 g = (TUint8)aColor.Green();

	const TUint8 b = (TUint8)aColor.Blue();

	while (aBuffer < dataLimit)

		{

		TUint32 dataWord = *aBuffer++;

		TUint32 dataMask = 1;

		TUint8* tempPixelPtr = pixelPtr;

		while (dataMask != dataMaskLimit)

			{

			if(dataWord & dataMask)

				{

				tempPixelPtr[0] = b;

				tempPixelPtr[1] = g;

				tempPixelPtr[2] = r;

				}

			tempPixelPtr += pixelInc;

			dataMask <<= 1;

			}

		pixelPtr += rowInc;

		}

	}

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

	{

	if (aLength <= 0)

		return;

	DeOrientate(aX,aY);

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint32* dataPtrLimit = aBuffer + aHeight;

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

	TInt pixelInc;

	TInt rowInc;

	PixelAddressIncrement(pixelInc,rowInc);

	const TUint8 r = (TUint8)aColor.Red();

	const TUint8 g = (TUint8)aColor.Green();

	const TUint8 b = (TUint8)aColor.Blue();

	if (r || g || b)

		{

		while (aBuffer < dataPtrLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint8* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					switch (aDrawMode)

						{

						case CGraphicsContext::EDrawModeXOR:

							tempPixelPtr[0] ^= b;

							tempPixelPtr[1] ^= g;

							tempPixelPtr[2] ^= r;

							break;

						case CGraphicsContext::EDrawModeAND:

							tempPixelPtr[0] &= b;

							tempPixelPtr[1] &= g;

							tempPixelPtr[2] &= r;

							break;

						case CGraphicsContext::EDrawModeOR:

							tempPixelPtr[0] |= b;

							tempPixelPtr[1] |= g;

							tempPixelPtr[2] |= r;

							break;

						default:

							break;

						}

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	else if (aDrawMode == CGraphicsContext::EDrawModeAND)

		{

		while (aBuffer < dataPtrLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint8* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					tempPixelPtr[0] = 0;

					tempPixelPtr[1] = 0;

					tempPixelPtr[2] = 0;

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	}

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

	{

	DeOrientate(aX,aY);

	TInt scanlineByteLength;

	switch (iOrientation)

		{

		case EOrientationNormal:

			scanlineByteLength = iScanLineBytes;

			break;

		case EOrientationRotated90:

			scanlineByteLength = -3;

			break;

		case EOrientationRotated180:

			scanlineByteLength = -iScanLineBytes;

			break;

		default: // EOrientationRotated270

			scanlineByteLength = 3;

			break;

		}

	if (aUp)

		scanlineByteLength = -scanlineByteLength;

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TUint8* pixelPtrLimit = pixelPtr + (aHeight * scanlineByteLength);

	TUint32 dataWord = *aBuffer;

	TUint32 dataMask = 1;

	const TUint8 r = (TUint8)aColor.Red();

	const TUint8 g = (TUint8)aColor.Green();

	const TUint8 b = (TUint8)aColor.Blue();

	while(pixelPtr != pixelPtrLimit)

		{

		if(!dataMask)

			{

			dataMask = 1;

			aBuffer++;

			dataWord = *aBuffer;

			}

		if(dataWord & dataMask)

			{

			pixelPtr[0] = b;

			pixelPtr[1] = g;

			pixelPtr[2] = r;

			}

		dataMask <<= 1;

		pixelPtr += scanlineByteLength;

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	if (iOrientation == EOrientationNormal)

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

	else

		{

		const TInt pixelPtrInc = PixelAddressIncrement();

		TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);

		TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);

		while (bufferPtr < bufferPtrLimit)

			{

			pixelPtr[0] = *bufferPtr++;

			pixelPtr[1] = *bufferPtr++;

			pixelPtr[2] = *bufferPtr++;

			pixelPtr += pixelPtrInc;

			}

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);

	TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);

	while (bufferPtr < bufferPtrLimit)

		{

		pixelPtr[0] ^= *bufferPtr++;

		pixelPtr[1] ^= *bufferPtr++;

		pixelPtr[2] ^= *bufferPtr++;

		pixelPtr += pixelPtrInc;

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);

	TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);

	while (bufferPtr < bufferPtrLimit)

		{

		pixelPtr[0] &= *bufferPtr++;

		pixelPtr[1] &= *bufferPtr++;

		pixelPtr[2] &= *bufferPtr++;

		pixelPtr += pixelPtrInc;

		}

	}

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

	{

	TUint8* pixelPtr = PixelAddress(aX,aY);