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

// CDrawTwelveBppBitmap

TInt CDrawTwelveBppBitmap::Construct(TSize aSize)

	{

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

	}

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

	{

	iDispMode = EColor4K;

	return CDrawSixteenBppBitmapCommon::Construct(aSize, aStride);

	}

void CDrawTwelveBppBitmap::Shadow(TRgb& aColor)

	{

	if (iShadowMode & EFade)

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

	if (iShadowMode & EShadow)

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

	}

TUint16 CDrawTwelveBppBitmap::ShadowIndex(TUint16 aColor4KIndex)

	{

	TInt red = (aColor4KIndex & 0xf00) >> 8;

	TInt green = (aColor4KIndex & 0x0f0) >> 4;

	TInt blue = aColor4KIndex & 0x00f;

	red = Max(0,red-5);

	green = Max(0,green-5);

	blue = Max(0,blue-5);

	return TUint16((red << 8) | (green << 4) | blue);

	}

TUint16 CDrawTwelveBppBitmap::FadeIndex(TUint16 aColor4KIndex)

	{

	return TUint16(FadeRgb(TRgb::_Color4K(aColor4KIndex))._Color4K());

	}

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

	{

	return TRgb::_Color4K(*PixelAddress(aX,aY));

	}

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

	{

	*PixelAddress(aX,aY) = TUint16(aColor._Color4K());

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteBinary(aX,aY,aData,aLength,aHeight,(TUint16)aColor._Color4K());

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteBinaryOp(aX,aY,aData,aLength,aHeight,(TUint16)aColor._Color4K(),aDrawMode);

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteBinaryLineVertical(aX,aY,aData,aHeight,(TUint16)aColor._Color4K(),aUp);

	}

/**

MAlphaBlend::WriteRgbAlphaLine() implementation.

@see MAlphaBlend::WriteRgbAlphaLine()

*/

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

                                             const TUint8* aRgbBuffer,

                                             const TUint8* aMaskBuffer,

                                             MAlphaBlend::TShadowing aShadowing,

                                             CGraphicsContext::TDrawMode /*aDrawMode*/)

    {

	DeOrientate(aX,aY);

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	TRgb pixelColor;

	while (aMaskBuffer < maskBufferPtrLimit)

		{

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

        if(aShadowing == MAlphaBlend::EShdwBefore)

            {

		    Shadow(srcColor);

            }

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

        if(aShadowing == MAlphaBlend::EShdwAfter)

            {

		    Shadow(pixelColor);

            }

		MapColorToUserDisplayMode(pixelColor);

		pixelPtr[0] = TUint16(pixelColor._Color4K());

		pixelPtr += pixelPtrInc;

		aRgbBuffer += 4;

		aMaskBuffer++;

		}

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteRgbMulti(aX,aY,aLength,aHeight,(TUint16)aColor._Color4K());

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteRgbMultiXOR(aX,aY,aLength,aHeight,(TUint16)aColor._Color4K());

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteRgbMultiAND(aX,aY,aLength,aHeight,(TUint16)aColor._Color4K());

	}

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

	{

	CDrawSixteenBppBitmapCommon::WriteRgbMultiOR(aX,aY,aLength,aHeight,(TUint16)aColor._Color4K());

	}

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

	{

	DeOrientate(aX,aY);

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	if (iShadowMode)

		Shadow(aColor);

	const TInt red = aColor.Red();

	const TInt green = aColor.Green();

	const TInt blue = aColor.Blue();

	while (aMaskBuffer < maskBufferPtrLimit)

		{

		pixelPtr[0] = TUint16(AlphaBlend(red,green,blue,TRgb::_Color4K(pixelPtr[0]),aMaskBuffer[0])._Color4K());

		pixelPtr += pixelPtrInc;

		aMaskBuffer++;

		}

	}

void CDrawTwelveBppBitmap::MapColorToUserDisplayMode(TRgb& aColor)

	{

	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;

	default:

		break;

		}

	}

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

	{

	TUint16* bufferPtr = (TUint16*)aBuffer;

	const TUint16* bufferLimit = bufferPtr + aLength;

	TRgb color;

	switch (iUserDispMode)

		{

	case EGray2:

		while (bufferPtr < bufferLimit)

			{

			color = TRgb::_Color4K(*bufferPtr);

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

			*bufferPtr++ = TUint16(color._Color4K());

			}

		break;

	case EGray4:

		while (bufferPtr < bufferLimit)

			{

			color = TRgb::_Color4K(*bufferPtr);

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

			*bufferPtr++ = TUint16(color._Color4K());

			}

		break;

	case EGray16:

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

		while (bufferPtr < bufferLimit)

			{

			color = TRgb::_Color4K(*bufferPtr);

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

			*bufferPtr++ = TUint16(color._Color4K());

			}

		break;

	case EColor16:

		while (bufferPtr < bufferLimit)

			{

			color = TRgb::_Color4K(*bufferPtr);

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

			*bufferPtr++ = TUint16(color._Color4K());

			}

		break;

	case EColor256:

		while (bufferPtr < bufferLimit)

			{

			color = TRgb::_Color4K(*bufferPtr);

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

			*bufferPtr++ = TUint16(color._Color4K());

			}

		break;

	default:

		break;

		}

	}

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

													TUint32 aOutlinePenColor, TUint32 aShadowColor,

													TUint32 aFillColor, const TUint8* aDataBuffer)

	{

	DeOrientate(aX,aY);

	TUint16* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = LogicalPixelAddressIncrement();

	const TUint8* dataBufferPtrLimit = aDataBuffer + aLength;

	TInt blendedRedColor;

	TInt blendedGreenColor;

	TInt blendedBlueColor;

	TUint8 index = 0;

	TUint32 finalColor;

	//Get red color. Equivalent to TRgb::Red()

	const TInt redOutlinePenColor = (aOutlinePenColor & 0xff0000) >> 16;

	const TInt redShadowColor = (aShadowColor & 0xff0000) >> 16;

	const TInt redFillColor = (aFillColor & 0xff0000) >> 16;

	//Get green color. Equivalent to TRgb::Green()

	const TInt greenOutlinePenColor = (aOutlinePenColor & 0xff00) >> 8;

	const TInt greenShadowColor = (aShadowColor & 0xff00) >> 8;

	const TInt greenFillColor = (aFillColor & 0xff00) >> 8;

	//Get blue color. Equivalent to TRgb::Blue()

	const TInt blueOutlinePenColor = aOutlinePenColor & 0xff;

	const TInt blueShadowColor = aShadowColor & 0xff;

	const TInt blueFillColor = aFillColor & 0xff;

	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])

			{

			//Use fill colour to draw

			finalColor = aFillColor;

			}

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

			{

			//Use shadow colour to draw

			finalColor = aShadowColor;

			}

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

			{

			//Use outline colour to draw

			finalColor = aOutlinePenColor;

			}

		else

			{

			//Get the background pixel colour. Equivalent to TRgb::_Color4K(TInt)

			TUint32 color = (*pixelPtr & 0xf00) << 8;

			color |= (*pixelPtr & 0x0f0) << 4;

			color |= (*pixelPtr & 0x00f);

			//Equivalent to TRgb::TRgb(TUint32, TInt) except that alpha is not set in background colour 

			//as it is not used for calculating final colour

			TUint32 backgroundColor = (((color | (color << 4)) & 0x00ffffff));

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

								redShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +

						  		redFillColor * FourColorBlendLookup[index][KFillColorIndex] + 

						  		((backgroundColor & 0xff0000) >> 16) * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;

			blendedGreenColor = (greenOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] + 

								greenShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +

								greenFillColor * FourColorBlendLookup[index][KFillColorIndex] + 

								((backgroundColor & 0xff00) >> 8) * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;

			blendedBlueColor = (blueOutlinePenColor * FourColorBlendLookup[index][KOutlineColorIndex] + 

								blueShadowColor * FourColorBlendLookup[index][KShadowColorIndex] +

								blueFillColor * FourColorBlendLookup[index][KFillColorIndex] + 

								(backgroundColor & 0xff) * FourColorBlendLookup[index][KBackgroundColorIndex]) >> 8;

			//Equivalent to TRgb::TRgb(TUint32)

			finalColor = (blendedRedColor << 16) | (blendedGreenColor << 8) | blendedBlueColor | 0xff000000;

			}

		//Convert 32 bit to 4K colour. Equivalent to TRgb::_Color4K(TInt)

		TInt finalColor4K = (finalColor & 0x0000f0) >> 4;

		finalColor4K |= (finalColor & 0x00f000) >> 8;

		finalColor4K |= (finalColor & 0xf00000) >> 12;

		//Draw the final colour

		*pixelPtr = finalColor4K;

		pixelPtr += pixelPtrInc;

		}

	return KErrNone;

	}