diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/screendriver/sbit/BMDRAW12.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/screendriver/sbit/BMDRAW12.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,338 @@
+// 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;
+	}