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