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

const TInt KEightBppPaletteSize = 256;

const TInt KEightBppInversePaletteSize = 4096;

GLREF_D const TUint8 color256shadowlutab[256];

// CDrawEightBppBitmapColor

TInt CDrawEightBppBitmapColor::Construct(TSize aSize)

	{

	return Construct(aSize, (aSize.iWidth + 3) & ~3);

	}

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

	{

	iDispMode = EColor256;

	iShadowIndex = (TUint8*)color256shadowlutab;

	return CDrawEightBppBitmapCommon::Construct(aSize, aStride);

	}

CDrawEightBppBitmapColor::~CDrawEightBppBitmapColor()

	{

	delete[] iPalette;

	delete[] iColor4KIndex;

	if (iShadowIndex != color256shadowlutab)

		delete[] iShadowIndex;

	}

TInt CDrawEightBppBitmapColor::SetCustomPalette(const CPalette* aPalette)

	{

	if (aPalette)

		{

		if (!iPalette)

			iPalette = new TRgb[KEightBppPaletteSize];

		if (!iColor4KIndex)

			iColor4KIndex = new TUint8[KEightBppInversePaletteSize];

		if (iShadowIndex == color256shadowlutab)

			iShadowIndex = new TUint8[KEightBppPaletteSize];

		if (iPalette && iColor4KIndex && iShadowIndex)

			{

			TInt index = 0;

			TRgb* palettePtr = iPalette;

			const TRgb* const palettePtrLimit = iPalette + Min(aPalette->Entries(),KEightBppPaletteSize);

			while (palettePtr < palettePtrLimit)

				*palettePtr++ = aPalette->GetEntry(index++);

			index = 0;

			TUint8* inversePtr = iColor4KIndex;

			const TUint8* const inversePtrLimit = iColor4KIndex + KEightBppInversePaletteSize;

			while (inversePtr < inversePtrLimit)

				*inversePtr++ = TUint8(aPalette->NearestIndex(TRgb::_Color4K(index++)));

			index = 0;

			TUint8* shadowPtr = iShadowIndex;

			const TUint8* const shadowPtrLimit = iShadowIndex + KEightBppPaletteSize;

			TRgb color;

			while (shadowPtr < shadowPtrLimit)

				{

				color = iPalette[index++];

				const TInt red = Max(color.Red() - 0x33,0) >> 4;

				const TInt green = Max(color.Green() - 0x33,0) >> 4;

				const TInt blue = Max(color.Blue() - 0x33,0) >> 4;

				*shadowPtr++ = iColor4KIndex[(red << 8) | (green << 4) | blue];

				}

			return KErrNone;

			}

		// Fall through to cleanup

		}

	delete[] iPalette;

	iPalette = NULL;

	delete[] iColor4KIndex;

	iColor4KIndex = NULL;

	if (iShadowIndex != color256shadowlutab)

		{

		delete[] iShadowIndex;

		iShadowIndex = (TUint8*)color256shadowlutab;

		}

	return aPalette ? KErrNoMemory : KErrNone;

	}

TInt CDrawEightBppBitmapColor::GetCustomPalette(CPalette*& aPalette)

	{

	TRAPD(err, aPalette = CPalette::NewDefaultL(EColor256));

	if (err == KErrNone && iPalette)

		{

		for (TInt index = 0; index < KEightBppPaletteSize; index++)

			aPalette->SetEntry(index, iPalette[index]);

		}

	return err;

	}

TUint8 CDrawEightBppBitmapColor::ColorToIndex(TRgb aColor) const

	{

	if (iColor4KIndex)

		return iColor4KIndex[aColor._Color4K()];

	return TUint8(aColor.Color256());

	}

TRgb CDrawEightBppBitmapColor::IndexToColor(TInt aIndex) const

	{

	if (iPalette)

		return iPalette[aIndex];

	return TRgb::Color256(aIndex);

	}

void CDrawEightBppBitmapColor::Shadow(TRgb& aColor)

	{

	if (iShadowMode & EFade)

		aColor = FadeRgb(IndexToColor(ColorToIndex(aColor)));

	if (iShadowMode & EShadow)

		aColor = IndexToColor(iShadowIndex[ColorToIndex(aColor)]);

	}

//aX, aY - physical coordinates

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

	{

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

	}

//aRect - logical coordinates

void CDrawEightBppBitmapColor::ShadowArea(const TRect& aRect)

	{

	const TRect rect(DeOrientate(aRect));//rect - physical coordinates

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

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

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

	TRgb color;

	register const TUint8* bitsEnd = 

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

	if(pixelRowPtrLimit >= bitsEnd)

		{

		pixelRowPtrLimit = bitsEnd;

		}

	if (iShadowMode & EFade)

		{

		TUint8* pixelRowPtr = pixelPtr;

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

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint8* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

				color = IndexToColor(*tempPixelPtr);

				color = FadeRgb(color);

				*tempPixelPtr++ = ColorToIndex(color);

				}

			pixelRowPtr += longWidth;

			pixelPtrLimit += longWidth;

			}

		}

	if (iShadowMode & EShadow)

		{

		TUint8* pixelRowPtr = pixelPtr;

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

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint8* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

				*tempPixelPtr = iShadowIndex[*tempPixelPtr];

				++tempPixelPtr;

				}

			pixelRowPtr += longWidth;

			pixelPtrLimit += longWidth;

			}

		}

	}

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

	{

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

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

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

	if (iShadowMode & EFade)

		{

		TUint8* buffer = (TUint8*)aBuffer;

		TRgb color;

		while (buffer < limit)

			{

			color = FadeRgb(IndexToColor(*buffer));

			*buffer++ = ColorToIndex(color);

			}

		}

	if (iShadowMode & EShadow)

		{

		TUint8* buffer = (TUint8*)aBuffer;

		while (buffer < limit)

			{

			*buffer = iShadowIndex[*buffer];

			++buffer;

			}

		}

	}

//aX, aY - physical coordinates

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

	{

	CDrawEightBppBitmapCommon::WriteRgb(aX,aY,ColorToIndex(aColor));

	}

//aX, aY - physical coordinates

void CDrawEightBppBitmapColor::WriteBinary(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TRgb aColor)

	{

	CDrawEightBppBitmapCommon::WriteBinary(aX,aY,aData,aLength,aHeight,ColorToIndex(aColor));

	}

//aX, aY - physical coordinates

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

	{

	CDrawEightBppBitmapCommon::WriteBinaryOp(aX,aY,aData,aLength,aHeight,ColorToIndex(aColor),aDrawMode);

	}

//aX, aY - physical coordinates

void CDrawEightBppBitmapColor::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aData,TInt aLength,TRgb aColor,TBool aUp)

	{

	CDrawEightBppBitmapCommon::WriteBinaryLineVertical(aX,aY,aData,aLength,ColorToIndex(aColor),aUp);

	}

/**

MAlphaBlend::WriteRgbAlphaLine() implementation.

@see MAlphaBlend::WriteRgbAlphaLine()

*/

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

                                                 const TUint8* aRgbBuffer,

                                                 const TUint8* aMaskBuffer,

                                                 MAlphaBlend::TShadowing aShadowing,

                                                 CGraphicsContext::TDrawMode /*aDrawMode*/)

    {

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

	TUint8* pixelPtr = PixelAddress(aX,aY);

	register TInt pixelPtrInc = LogicalPixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	TRgb pixelColor;

	if(iScalingOff)

		{

		while (aMaskBuffer < maskBufferPtrLimit)

			{

            TRgb srcColor(aRgbBuffer[2],aRgbBuffer[1],aRgbBuffer[0]);

            if(aShadowing == MAlphaBlend::EShdwBefore)

                {

		        Shadow(srcColor);

                }

            pixelColor = ::AlphaBlend(srcColor,IndexToColor(pixelPtr[0]),aMaskBuffer[0]);

            if(aShadowing == MAlphaBlend::EShdwAfter)

                {

		        Shadow(pixelColor);

                }

			MapColorToUserDisplayMode(pixelColor);

			pixelPtr[0] = ColorToIndex(pixelColor);

			pixelPtr += pixelPtrInc;

			aRgbBuffer += 4;

			aMaskBuffer++;

			}

		}

	else

		{

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

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

		while (aMaskBuffer < maskBufferPtrLimit)

			{

            TRgb srcColor(aRgbBuffer[2],aRgbBuffer[1],aRgbBuffer[0]);

            if(aShadowing == MAlphaBlend::EShdwBefore)

                {

		        Shadow(srcColor);

                }

            pixelColor = ::AlphaBlend(srcColor,IndexToColor(pixelPtr[0]),aMaskBuffer[0]);

            if(aShadowing == MAlphaBlend::EShdwAfter)

                {

		        Shadow(pixelColor);

                }

			MapColorToUserDisplayMode(pixelColor);

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

			SetPixels(pixelPtr, ColorToIndex(pixelColor), pixelRowPtrLimit, bitsStart, bitsEnd);

			pixelPtr += pixelPtrInc;

			aRgbBuffer += 4;

			aMaskBuffer++;

			IncScaledY(aY);

			}

		}

	}

void CDrawEightBppBitmapColor::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)

	{

	CDrawEightBppBitmapCommon::WriteRgbMulti(aX,aY,aLength,aRows,ColorToIndex(aColor));

	}

void CDrawEightBppBitmapColor::WriteRgbMultiXOR(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)

	{

	CDrawEightBppBitmapCommon::WriteRgbMultiXOR(aX,aY,aLength,aRows,ColorToIndex(aColor));

	}

void CDrawEightBppBitmapColor::WriteRgbMultiAND(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)

	{

	CDrawEightBppBitmapCommon::WriteRgbMultiAND(aX,aY,aLength,aRows,ColorToIndex(aColor));

	}

void CDrawEightBppBitmapColor::WriteRgbMultiOR(TInt aX,TInt aY,TInt aLength,TInt aRows,TRgb aColor)

	{

	CDrawEightBppBitmapCommon::WriteRgbMultiOR(aX,aY,aLength,aRows,ColorToIndex(aColor));

	}

//aX, aY - not deorientated

//aLength - not scaled

void CDrawEightBppBitmapColor::WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,

												  TRgb aColor,const TUint8* aMaskBuffer)

	{

	DeOrientate(aX,aY);//aX, aY - scaled and deorientated

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

	register TInt pixelPtrInc = LogicalPixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	if (iShadowMode)

		Shadow(aColor);

	register TInt red = aColor.Red();

	register TInt green = aColor.Green();

	register TInt blue = aColor.Blue();

	TRgb pixelColor;

	if(iScalingOff)

		{

		while(aMaskBuffer < maskBufferPtrLimit)

			{

			pixelColor = AlphaBlend(red, green, blue, IndexToColor(pixelPtr[0]), aMaskBuffer[0]);

			pixelPtr[0] = ColorToIndex(pixelColor);

			pixelPtr += pixelPtrInc;

			aMaskBuffer++;

			}

		}

	else

		{

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

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

		while(aMaskBuffer < maskBufferPtrLimit)

			{

			pixelColor = AlphaBlend(red, green, blue, IndexToColor(pixelPtr[0]), aMaskBuffer[0]);

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

			SetPixels(pixelPtr, ColorToIndex(pixelColor), pixelRowPtrLimit, bitsStart, bitsEnd);

			pixelPtr += pixelPtrInc;

			aMaskBuffer++;

			IncScaledY(aY);

			}

		}

	}

void CDrawEightBppBitmapColor::MapColorToUserDisplayMode(TRgb& aColor)

	{

	switch (iUserDispMode)

		{

	case EGray2:

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

		break;

	case EGray4:

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

		break;

	case EGray16:

	case EGray256:// EGray256 can't be done - nearest is EGray16

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

		break;

	case EColor16:

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

		break;

	default:

		break;

		}

	}

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

	{

	TUint8* bufferPtr = (TUint8*)aBuffer;

	const TUint8* bufferLimit = bufferPtr + aLength;

	TRgb color;

	switch (iUserDispMode)

		{

	case EGray2:

		while (bufferPtr < bufferLimit)

			{

			color = IndexToColor(*bufferPtr);

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

			*bufferPtr++ = ColorToIndex(color);

			}

		break;

	case EGray4:

		while (bufferPtr < bufferLimit)

			{

			color = IndexToColor(*bufferPtr);

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

			*bufferPtr++ = ColorToIndex(color);

			}

		break;

	case EGray16:

	case EGray256:// EGray256 can't be done - nearest is EGray16

		while (bufferPtr < bufferLimit)

			{

			color = IndexToColor(*bufferPtr);

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

			*bufferPtr++ = ColorToIndex(color);

			}

		break;

	case EColor16:

		while (bufferPtr < bufferLimit)

			{

			color = IndexToColor(*bufferPtr);

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

			*bufferPtr++ = ColorToIndex(color);

			}

		break;

	default:

		break;

		}

	}

TInt CDrawEightBppBitmapColor::WriteRgbOutlineAndShadow(TInt aX, TInt aY, const TInt aLength,

	                                   TUint32 aOutlinePenColor, TUint32 aShadowColor,

	                                   TUint32 aFillColor, const TUint8* aDataBuffer)

	{

	//This is non-optimised since this screen mode is rarely used and is usually 

	//fast enough without optimisation.

	DeOrientate(aX,aY);

	TUint8* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = LogicalPixelAddressIncrement();

	const TUint8* dataBufferPtrLimit = aDataBuffer + aLength;

	TInt blendedRedColor;

	TInt blendedGreenColor;

	TInt blendedBlueColor;

	TUint8 index = 0;

	TRgb finalColor;

	TRgb outlinePenColor;

	outlinePenColor.SetInternal(aOutlinePenColor);

	TRgb shadowColor;

	shadowColor.SetInternal(aShadowColor);

	TRgb fillColor;

	fillColor.SetInternal(aFillColor);

	const TInt redOutlinePenColor = outlinePenColor.Red();

	const TInt redShadowColor = shadowColor.Red();

	const TInt redFillColor = fillColor.Red();

	const TInt greenOutlinePenColor = outlinePenColor.Green();

	const TInt greenShadowColor = shadowColor.Green();

	const TInt greenFillColor = fillColor.Green();

	const TInt blueOutlinePenColor = outlinePenColor.Blue();

	const TInt blueShadowColor = shadowColor.Blue();

	const TInt blueFillColor = fillColor.Blue();

	while (aDataBuffer < dataBufferPtrLimit)

		{

		index = *aDataBuffer++;

		if (255 == FourColorBlendLookup[index][KBackgroundColorIndex])

			{

			//background colour

			//No drawing required so move on to next pixel.

			pixelPtr += pixelPtrInc;

			continue;

			}

		else if (255 == FourColorBlendLookup[index][KFillColorIndex])

			{

			//fill colour

			finalColor.SetInternal(aFillColor);

			}

		else if (255 == FourColorBlendLookup[index][KShadowColorIndex])

			{

			//Shadow colour

			finalColor.SetInternal(aShadowColor);

			}

		else if (255 == FourColorBlendLookup[index][KOutlineColorIndex])

			{

			//Outline colour

			finalColor.SetInternal(aOutlinePenColor);

			}

		else

			{

			TRgb backgroundColor = TRgb::Color256(*pixelPtr);

			blendedRedColor = (redOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] +