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

		}

	}