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

#include <graphics/lookuptable.h>

#if defined(SYMBIAN_USE_FAST_FADING)

// 16bpp fast fade - half the contrast and brighten

const TInt K16bppFastFadeShift = 1;

const TUint16 K16bppFastFadeMask = 0x8410;

// Use the 32 -> 16 bit colour convesrion method to get

// the 16 bit fading constant (K16bppFastFadeOffset)

// from 32 bit fading constant (SYMBIAN_USE_FAST_FADING).

const TUint16 K16bppFastFadeOffset = ((SYMBIAN_USE_FAST_FADING & 0x0000f8) >> 3) |

									((SYMBIAN_USE_FAST_FADING & 0x00fc00) >> 5) |

									((SYMBIAN_USE_FAST_FADING & 0xf80000) >> 8);

#endif

// CDrawSixteenBppBitmapCommon

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

	{

	CDrawBitmap::SetSize(aSize);

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

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

	iScanLineWords = iLongWidth >> 1;

	}

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

	{

	iBits = NULL;

	CDrawBitmap::SetSize(aSize);

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

	if (aStride & 3)

		return KErrArgument;

	iLongWidth = aStride >> 1;

	if (iLongWidth < aSize.iWidth)

		return KErrArgument;

	iScanLineWords = aStride >> 2;

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

	if(size < 0)

		return KErrArgument;

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

	if (iScanLineBuffer == NULL)

		return KErrNoMemory;

	return KErrNone;

	}

TUint16* CDrawSixteenBppBitmapCommon::PixelAddress(TInt aX,TInt aY) const

	{

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

	}

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

	{

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

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	const TUint32* limit = aBuffer + ((aLength + 1) >> 1);

	while (aBuffer < limit)

		*aBuffer++ ^= 0xffffffff;

	}

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

	const TInt longWidth = iLongWidth;

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

	const TUint16* pixelRowPtrLimit = pixelPtr + (rect.Height() * longWidth);

	if (iShadowMode & EFade)

		{

		TUint16* pixelRowPtr = pixelPtr;

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

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			for (TUint16* tempPixelPtr = pixelRowPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

				tempPixelPtr[0] = FadeIndex(tempPixelPtr[0]);

			pixelRowPtr += longWidth;

			pixelPtrLimit += longWidth;

			}

		}

	if (iShadowMode & EShadow)

		{

		TUint16* pixelRowPtr = pixelPtr;

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

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			for (TUint16* tempPixelPtr = pixelRowPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

				tempPixelPtr[0] = ShadowIndex(tempPixelPtr[0]);

			pixelRowPtr += longWidth;

			pixelPtrLimit += longWidth;

			}

		}

	}

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

	{

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

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	const TUint16* limit = ((TUint16*)aBuffer) + aLength;

	if (iShadowMode & EFade)

		{

		for (TUint16* buffer = (TUint16*)aBuffer; buffer < limit; buffer++)

			buffer[0] = FadeIndex(buffer[0]);

		}

	if (iShadowMode & EShadow)

		{

		for (TUint16* buffer = (TUint16*)aBuffer; buffer < limit; buffer++)

			buffer[0] = ShadowIndex(buffer[0]);

		}

	}

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

	{

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

	if (iOrientation == EOrientationNormal && iScalingOff)

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

	else

		{

		const TInt pixelPtrInc = LogicalPixelAddressIncrement();

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

		const TUint16* bufferPtrLimit = bufferPtr + aLength;

		while (bufferPtr < bufferPtrLimit)

			{

			*bufferPtr++ = *pixelPtr;

			pixelPtr += pixelPtrInc;

			}

		}

	}

void CDrawSixteenBppBitmapCommon::WriteBinary(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TUint16 aColor)

	{

	DeOrientate(aX,aY);

	TInt pixelInc;

	TInt rowInc;

	SetPixelInc(pixelInc, rowInc);

	const TUint32* dataLimit = aData + aHeight;

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

	TUint16* pixelPtr = PixelAddress(aX,aY);

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

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

	TInt orgY = aY;

	while (aData < dataLimit)

		{

		TUint32 dataWord = *aData++;

		TUint32 dataMask = 1;

		TUint16* tempPixelPtr = pixelPtr;

		if (iScalingOff)

			{

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					*tempPixelPtr = aColor;

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			}

		else

			{

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

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

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

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				IncScaledY(aY);

				}

			}

		pixelPtr += rowInc;

		IncScaledY(aY, orgY);		

		}

	}

void CDrawSixteenBppBitmapCommon::WriteBinaryOp(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TUint16 aColor,CGraphicsContext::TDrawMode aDrawMode)

	{

	if (aLength <= 0)

		return;

	DeOrientate(aX,aY);

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TUint32* dataPtrLimit = aData + aHeight;

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

	TInt pixelInc;

	TInt rowInc;

	SetPixelInc(pixelInc, rowInc);

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

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

	TInt orgY = aY;

	if (aColor)

		{

		while (aData < dataPtrLimit)

			{

			TUint32 dataWord = *aData++;

			TUint32 dataMask = 1;

			TUint16* tempPixelPtr = pixelPtr;

			if (iScalingOff)

				{

				while (dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

						if(aDrawMode==CGraphicsContext::EDrawModeXOR)

							*tempPixelPtr ^= aColor;

						else if(aDrawMode==CGraphicsContext::EDrawModeAND)

							*tempPixelPtr &= aColor;

						else if(aDrawMode==CGraphicsContext::EDrawModeOR)

							*tempPixelPtr |= aColor;

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			else

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

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

						if(aDrawMode==CGraphicsContext::EDrawModeXOR)

							{

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

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeAND)

							{

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

							}

						else if(aDrawMode==CGraphicsContext::EDrawModeOR)

							{

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

							}

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					IncScaledY(aY);

					}

				}

			pixelPtr += rowInc;

			IncScaledY(aY, orgY);			

			}

		}

	else if(aDrawMode==CGraphicsContext::EDrawModeAND)

		{

		while (aData < dataPtrLimit)

			{

			TUint32 dataWord = *aData++;

			TUint32 dataMask = 1;

			TUint16* tempPixelPtr = pixelPtr;

			if (iScalingOff)

				{

				while (dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						*tempPixelPtr = 0;

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			else

				{

				while(dataMask != dataMaskLimit)

					{

					if(dataWord & dataMask)

						{

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

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

						}

					tempPixelPtr += pixelInc;

					dataMask <<= 1;

					}

				}

			pixelPtr += rowInc;

			IncScaledY(aY, orgY);			

			}

		}

	}

void CDrawSixteenBppBitmapCommon::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aData,TInt aHeight,TUint16 aColor,TBool aUp)

	{

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

	DeOrientate(aX,aY);

	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;

	TUint16* pixelPtr = PixelAddress(aX,aY);

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

	TUint32 dataWord = *aData;

	TUint32 dataMask = 1;

	while(pixelPtr != pixelPtrLimit)

		{

		if(!dataMask)

			{

			dataMask = 1;

			aData++;

			dataWord = *aData;

			}

		if(dataWord & dataMask)

			*pixelPtr = aColor;

		dataMask <<= 1;

		pixelPtr += scanlineByteLength;

		}

	}

void CDrawSixteenBppBitmapCommon::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TUint16 aColor)

	{

	const TInt longWidth = iLongWidth;

	const TInt scanLineWords = iScanLineWords;

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TUint16* pixelRowPtrLimit = pixelPtr + (aHeight * longWidth);

	if ((aColor >> 8) == (TUint8)aColor)

		{

		while (pixelPtr < pixelRowPtrLimit)

			{

			Mem::Fill(pixelPtr,aLength * 2,TUint8(aColor));

			pixelPtr += longWidth;

			}

		}

	else

		{

		const TBool leadingPixel = aX & 1;

		const TBool trailingPixel = (aX + aLength) & 1;

		const TUint32 colorWord = (aColor << 16) | aColor;

		TUint16* lastPixelPtr = pixelPtr + aLength - 1;

		TUint32* wordPtr = REINTERPRET_CAST(TUint32*,pixelPtr + (leadingPixel ? 1 : 0));

		TUint32* wordPtrLimit = REINTERPRET_CAST(TUint32*,lastPixelPtr + (trailingPixel ? 0 : 1));

		__ASSERT_DEBUG(!(TInt(wordPtr) & 3),Panic(EScreenDriverPanicInvalidPointer));

		__ASSERT_DEBUG(!(TInt(wordPtrLimit) & 3),Panic(EScreenDriverPanicInvalidPointer));

		if (leadingPixel)

			{

			while (pixelPtr < pixelRowPtrLimit)

				{

				pixelPtr[0] = aColor;

				pixelPtr += longWidth;

				}

			}

		while (wordPtr < (TUint32*)pixelRowPtrLimit)

			{

			MemFillTUint32(wordPtr, wordPtrLimit-wordPtr, colorWord);

			wordPtr += scanLineWords;

			wordPtrLimit += scanLineWords;

			}

		if (trailingPixel)

			{

			while (lastPixelPtr < pixelRowPtrLimit)

				{

				lastPixelPtr[0] = aColor;

				lastPixelPtr += longWidth;

				}

			}

		}

	}

void CDrawSixteenBppBitmapCommon::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TUint16 aColor)

	{

	const TInt longWidth = iLongWidth;

	TUint16* pixelPtr = PixelAddress(aX,aY);

	TUint16* pixelPtrLimit = pixelPtr + aLength;

	const TUint16* pixelRowPtrLimit = pixelPtr + (aHeight * longWidth);

	while (pixelPtr < pixelRowPtrLimit)

		{

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

			tempPixelPtr[0] ^= aColor;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

void CDrawSixteenBppBitmapCommon::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aHeight,TUint16 aColor)

	{

	const TInt longWidth = iLongWidth;

	TUint16* pixelPtr = PixelAddress(aX,aY);

	TUint16* pixelPtrLimit = pixelPtr + aLength;

	const TUint16* pixelRowPtrLimit = pixelPtr + (aHeight * longWidth);

	while (pixelPtr < pixelRowPtrLimit)

		{

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

			tempPixelPtr[0] &= aColor;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

void CDrawSixteenBppBitmapCommon::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aHeight,TUint16 aColor)

	{

	const TInt longWidth = iLongWidth;

	TUint16* pixelPtr = PixelAddress(aX,aY);

	TUint16* pixelPtrLimit = pixelPtr + aLength;

	const TUint16* pixelRowPtrLimit = pixelPtr + (aHeight * longWidth);

	while (pixelPtr < pixelRowPtrLimit)

		{

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

			tempPixelPtr[0] |= aColor;

		pixelPtr += longWidth;

		pixelPtrLimit += longWidth;

		}

	}

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

	{

	TUint16* pixelPtr = PixelAddress(aX,aY);

	if (iOrientation == EOrientationNormal && iScalingOff)

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

	else

		{

		const TInt pixelPtrInc = LogicalPixelAddressIncrement();

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

		TUint16* bufferPtrLimit = bufferPtr + aLength;

		if (iScalingOff)

			{

			while (bufferPtr < bufferPtrLimit)

				{

				*pixelPtr = *bufferPtr++;

				pixelPtr += pixelPtrInc;

				}

			}

		else

			{

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

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

			while(bufferPtr < bufferPtrLimit)

				{

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

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

				pixelPtr += pixelPtrInc;

				IncScaledY(aY);

				}

			}

		}

	}

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

	{

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = LogicalPixelAddressIncrement();

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

	const TUint16* bufferPtrLimit = bufferPtr + aLength;

	if (iScalingOff)

		{

		while (bufferPtr < bufferPtrLimit)

			{

			*pixelPtr ^= *bufferPtr++;

			pixelPtr += pixelPtrInc;

			}

		}

	else

		{

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

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

		while(bufferPtr < bufferPtrLimit)

			{

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

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

			pixelPtr += pixelPtrInc;

			IncScaledY(aY);

			}

		}