// 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"
GLDEF_C void Panic(TScreenDriverPanic aPanicCode)
{
_LIT(KSCDVPanicCategory,"SCDV");
User::Panic(KSCDVPanicCategory,aPanicCode);
}
/**
Alphablends a pixel.
The formula used for that, is:
(aPrimary * aAlphaValue + aSecondary * (255 - aAlphaValue)) / 255 - for each color (R,G,B).
@param aPrimary RGB color 1.
@param aSecondary RGB color 2.
@param aAlphaValue Mask.
@return Alpha blended value.
@internalComponent
*/
TRgb AlphaBlend(TRgb aPrimary, TRgb aSecondary, TInt aAlphaValue)
{
return ::AlphaBlend(aPrimary.Red(), aPrimary.Green(), aPrimary.Blue(), aSecondary, aAlphaValue);
}
GLREF_D const TUint8 ditherlutab[16][4];
const TInt8 xIncArray[4] = { 1, 0, -1, 0 };
const TInt8 yIncArray[4] = { 0, 1, 0, -1 };
static CFbsDrawDevice* CreateBitmapDeviceL(const TSize& aSize, TDisplayMode aDispMode, TInt aDataStride)
{
CFbsDrawDevice* drawDevice = NULL;
switch(aDispMode)
{
case EGray2:
drawDevice = new(ELeave) CDrawOneBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawOneBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EGray4:
drawDevice = new(ELeave) CDrawTwoBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawTwoBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EGray16:
drawDevice = new(ELeave) CDrawFourBppBitmapGray;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawFourBppBitmapGray*)drawDevice)->Construct(aSize, aDataStride));
break;
case EGray256:
drawDevice = new(ELeave) CDrawEightBppBitmapGray;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawEightBppBitmapGray*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor16:
drawDevice = new(ELeave) CDrawFourBppBitmapColor;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawFourBppBitmapColor*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor256:
drawDevice = new(ELeave) CDrawEightBppBitmapColor;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawEightBppBitmapColor*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor4K:
drawDevice = new(ELeave) CDrawTwelveBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawTwelveBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor64K:
drawDevice = new(ELeave) CDrawSixteenBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawSixteenBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor16M:
drawDevice = new(ELeave) CDrawTwentyFourBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawTwentyFourBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor16MU:
drawDevice = new(ELeave) CDrawUTwentyFourBppBitmap;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawUTwentyFourBppBitmap*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor16MA:
drawDevice = new(ELeave) CDrawThirtyTwoBppBitmapAlpha;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawThirtyTwoBppBitmapAlpha*)drawDevice)->Construct(aSize, aDataStride));
break;
case EColor16MAP:
drawDevice = new(ELeave) CDrawThirtyTwoBppBitmapAlphaPM;
CleanupStack::PushL(drawDevice);
User::LeaveIfError(((CDrawThirtyTwoBppBitmapAlphaPM*)drawDevice)->Construct(aSize, aDataStride));
break;
default:
Panic(EScreenDriverPanicInvalidDisplayMode);
}
CleanupStack::Pop(drawDevice); // drawDevice
return drawDevice;
}
/**
@deprecated Use NewBitmapDeviceL(const TSize& aSize, TDisplayMode aDispMode, TInt aDataStride)
*/
EXPORT_C CFbsDrawDevice* CFbsDrawDevice::NewBitmapDeviceL(TScreenInfoV01 aInfo,
TDisplayMode aDispMode,
TInt aDataStride)
{
return ::CreateBitmapDeviceL(aInfo.iScreenSize, aDispMode, aDataStride);
}
/**
Creates a new bitmap device instance, which implements CFbsDrawDevice interface.
@param aSize Bitmap device size
@param aDispMode Requested display mode
@return A pointer to just created bitmap device, which implements CFbsDrawDevice interface
@leave KErrNoMemory Not enough memory
KErrArgument Invalid aSize value
*/
EXPORT_C CFbsDrawDevice* CFbsDrawDevice::NewBitmapDeviceL(const TSize& aSize,
TDisplayMode aDispMode,
TInt aDataStride)
{
return ::CreateBitmapDeviceL(aSize, aDispMode, aDataStride);
}
//Logical coordinates will be initialized with the right values, when SetSize() is called.
CDrawBitmap::CDrawBitmap()
{
SetDefaults();
TInt err = GetInterface(KAlphaBlendInterfaceID, reinterpret_cast <TAny*&> (iAlphaBlend));
//There must be a support for an interface with KAlphaBlendInterfaceID id.
__ASSERT_ALWAYS(iAlphaBlend && err == KErrNone, User::Invariant());
}
//Scanline width in pixels.
//The return value can be greater or equal than iSize.iWidth, because
//the scan line memory is allocated in 32-bit words and can be rounded up, if
//the display mode allows more than 1 pixel to be stored in a single byte.
TInt CDrawBitmap::LongWidth() const
{
//0 or 180 dgrees
if(!(iOrientation & 1))
{
return iLongWidth;
}
//90 or 270 degrees
return iSize.iWidth == 0 ? 0 : iLongWidth * iSize.iHeight / iSize.iWidth;
}
TUint32* CDrawBitmap::ScanLineBuffer() const
{
return iScanLineBuffer;
}
//Scanline width in bytes
TInt CDrawBitmap::ScanLineBytes() const
{
register TInt scanLineBytes = iScanLineWords << 2;
//90 or 270 degrees
if(iOrientation & 1)
{
return iSize.iWidth == 0 ? 0 : scanLineBytes * iSize.iHeight / iSize.iWidth;
}
//0 or 180 degrees
return scanLineBytes;
}
/**
The method returns screen size in pixels. The orientation is taken into account.
Always prefer GetDrawRect() to SizeInPixels() call.
GetDrawRect() will take into account possible non-[0,0] top-left corner of the drawing
rectangle if the device is scaled.
@return TSize Screen size in pixels
*/
TSize CDrawBitmap::SizeInPixels() const
{
//90 or 270 degrees
if(iOrientation & 1)
{
return TSize(iDrawRect.Height(), iDrawRect.Width());
}
//0 or 180 degrees
return iDrawRect.Size();
}
//aPoint - logical coordinates
void CDrawBitmap::SetDitherOrigin(const TPoint& aPoint)
{
if (iOrientation&1)
{
iDitherOrigin.iX = ::Log2Phys(aPoint.iX,iOrigin.iX,iScalingSettings.iFactorY,iSize.iHeight);
iDitherOrigin.iY = ::Log2Phys(aPoint.iY,iOrigin.iY,iScalingSettings.iFactorX,iSize.iWidth);
}
else
{
iDitherOrigin.iX = ::Log2Phys(aPoint.iX,iOrigin.iX,iScalingSettings.iFactorX,iSize.iWidth);
iDitherOrigin.iY = ::Log2Phys(aPoint.iY,iOrigin.iY,iScalingSettings.iFactorY,iSize.iHeight);
}
}
TInt CDrawBitmap::BitsPerPixel(TDisplayMode aDispMode)
{
switch(aDispMode)
{
case EGray2:
return 1;
case EGray4:
return 2;
case EGray16:
case EColor16:
return 4;
case EGray256:
case EColor256:
return 8;
case EColor4K:
case EColor64K:
return 16;
case EColor16M:
return 24;
case EColor16MU:
case EColor16MA:
case EColor16MAP:
return 32;
default:
return 0;
}
}
void CDrawBitmap::OrientationsAvailable(TBool aOrientation[4])
{
aOrientation[EOrientationNormal] = ETrue;
aOrientation[EOrientationRotated90] = EFalse;
aOrientation[EOrientationRotated180] = EFalse;
aOrientation[EOrientationRotated270] = EFalse;
}
//Works with logical coordinates
void CDrawBitmap::Clear()
{
if(iBits)
{
if(iScalingOff && iOriginIsZero)
{
Mem::Fill(iBits, iScanLineWords * 4 * iSize.iHeight, 0xFF);
}
else
{
TShadowMode storedShadowMode = iShadowMode;
iShadowMode = ENoShadow;
TRect drawRect;
GetDrawRect(drawRect);
WriteRgbMulti(drawRect.iTl.iX, drawRect.iTl.iY, drawRect.Width(), drawRect.Height(), KRgbWhite, CGraphicsContext::EDrawModeWriteAlpha);
iShadowMode = storedShadowMode;
}
}
}
CDrawBitmap::~CDrawBitmap()
{
if(iScanLineBuffer)
{
User::Free(iScanLineBuffer);
}
}
//Works with logical sizes
//The new device will accept old device scalling&scaling settings
//All graphics contexts, already created by the scaled device, should be
//re-activated calling CFbsBitGc::Activate().
void CDrawBitmap::CopyOldSettings(CFbsDrawDevice* aDrawDevice)
{
__ASSERT_DEBUG(aDrawDevice, User::Invariant());
//Scaling&Origin settings - their values when scaling&origin are off.
const TPoint KDefaultOrigin(0, 0);
const TInt KDefaultFactorX = 1, KDefaultFactorY = 1;
const TInt KDefaultDivisorX = 1, KDefaultDivisorY = 1;
TPoint origin = KDefaultOrigin;//old device origin
TInt factorX = KDefaultFactorX, factorY = KDefaultFactorY;//old device - X and Y scaling factors
TInt divisorX = KDefaultDivisorX, divisorY = KDefaultDivisorY;//old device - X and Y scaling divisors
//Old device - set default scaling setings.
MScalingSettings* scalingSettings = NULL;
TInt err = aDrawDevice->GetInterface(KScalingSettingsInterfaceID, reinterpret_cast <TAny*&> (scalingSettings));
if(err == KErrNone)
{//There is a support for the interface with KScalingSettingsInterfaceID id.
__ASSERT_DEBUG(scalingSettings, User::Invariant());
scalingSettings->Get(factorX, factorY, divisorX, divisorY);
(void)scalingSettings->Set(KDefaultFactorX, KDefaultFactorY, KDefaultDivisorX, KDefaultDivisorY);
}
//Current device - set default scaling setings.
if(CanBeScaled())
{
(void)Set(KDefaultFactorX, KDefaultFactorY, KDefaultDivisorX, KDefaultDivisorY);
}
//Old device - set default origin.
MDrawDeviceOrigin* originInterface = NULL;
err = aDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, reinterpret_cast <TAny*&> (originInterface));
if(err == KErrNone)
{//There is a support for the interface with KDrawDeviceOriginInterfaceID id.
__ASSERT_DEBUG(originInterface, User::Invariant());
originInterface->Get(origin);
(void)originInterface->Set(KDefaultOrigin);
}
//Current device - set default origin.
if(CanOriginBeMoved())
{
(void)Set(KDefaultOrigin);
}
//Copy setigns
DoCopyOldSettings(aDrawDevice);
//Old device - restore scaling setings.
if(scalingSettings)
{
(void)scalingSettings->Set(factorX, factorY, divisorX, divisorY);
}
//Old device - restore origin.
if(originInterface)
{
(void)originInterface->Set(origin);
}
//Set current device scaling&origin settings to be the same as
//scaling&origin settings of the old device.
if(CanBeScaled())
{
(void)Set(factorX, factorY, divisorX, divisorY);
}
if(CanOriginBeMoved())
{
(void)Set(origin);
}
}
void CDrawBitmap::DoCopyOldSettings(CFbsDrawDevice* aDrawDevice)
{
CDrawBitmap* oldDevice = (CDrawBitmap*)aDrawDevice;
iDitherOrigin = oldDevice->iDitherOrigin;
iShadowMode = oldDevice->iShadowMode;
SetOrientation(oldDevice->iOrientation);
iFadeMapFactor = oldDevice->iFadeMapFactor;
iFadeMapOffset = oldDevice->iFadeMapOffset;
TUint32* destRowPtr = iBits;
TUint32* destRowPtrLimit = iBits;
TInt destRowPtrInc = iScanLineWords;
TInt row = 0;
TInt rowInc = 1;
if (BitsPerPixel(oldDevice->iDispMode) < BitsPerPixel(iDispMode))
{
destRowPtr += (iSize.iHeight - 1) * iScanLineWords;
destRowPtrInc = -destRowPtrInc;
destRowPtrLimit -= iScanLineWords;
row = iSize.iHeight - 1;
rowInc = -1;
}
else
destRowPtrLimit += iSize.iHeight * iScanLineWords;
TOrientation oldOrientation=oldDevice->iOrientation;
oldDevice->SetOrientation(CFbsDrawDevice::EOrientationNormal);
while (destRowPtr != destRowPtrLimit)
{
aDrawDevice->ReadLine(0,row,iSize.iWidth,iScanLineBuffer,iDispMode);
Mem::Copy(destRowPtr,iScanLineBuffer,iScanLineWords << 2);
destRowPtr += destRowPtrInc;
row += rowInc;
}
oldDevice->SetOrientation(oldOrientation);
UpdateRegion(TRect(SizeInPixels()));
Update();
}
TUint32 CDrawBitmap::Hash(TUint32 aGray16,TInt aX,TInt aY) const
{
if (iDitherOrigin.iX & 1)
aX++;
if (iDitherOrigin.iY & 1)
aY++;
aX &= 1;
aY &= 1;
return ditherlutab[aGray16][aX + (aY << 1)];
}
//aRect - logical coordinates
void CDrawBitmap::MapColors(const TRect& aRect, const TRgb* aColors,
TInt aNumPairs, TBool aMapForwards)
{
const TRect rect = DeOrientate(aRect);//deorientation and transformation of coordinates.
//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));
__ASSERT_DEBUG(aColors,Panic(EScreenDriverPanicNullPointer));
__ASSERT_DEBUG(aNumPairs > 0,Panic(EScreenDriverPanicZeroLength));
TRgb color;
TInt offset = aMapForwards ? 0 : 1;
TInt scaleX;
TInt scaleY;
if (iOrientation&1)
{
scaleX=iScalingSettings.iFactorY;
scaleY=iScalingSettings.iFactorX;
}
else
{
scaleX=iScalingSettings.iFactorX;
scaleY=iScalingSettings.iFactorY;
}
for(TInt ycoord = rect.iTl.iY; ycoord < rect.iBr.iY; ycoord+=scaleY)
{
for(TInt xcoord = rect.iTl.iX; xcoord < rect.iBr.iX; xcoord+=scaleX)
{
color = ReadRgbNormal(xcoord,ycoord);
for (TInt rgbcount = 0; rgbcount < aNumPairs; rgbcount++)
{
if (color == aColors[(rgbcount << 1) + offset])
{
WriteRgb(xcoord,ycoord,aColors[(rgbcount << 1) + 1 - offset]);
break;
}
}
}
}
}
//form an int from the end portion of one and the start portion of another
TUint32 CDrawBitmap::PasteInt(TUint32 aFirst,TUint32 aSecond,TInt aOffset) const
{
TUint32 mask=0;
if(aOffset<32) mask=0xffffffff>>aOffset;
aFirst&=mask;
aSecond&=~mask;
return(aFirst|aSecond);
}
//returns the address of the start of scanline aY
//aY- physical coordinate
TUint32* CDrawBitmap::ScanLine(TInt aY) const
{
return iBits + (aY * iScanLineWords);
}
void CDrawBitmap::SetBits(TAny* aBits)
{
iBits = STATIC_CAST(TUint32*,aBits);
}
TBool CDrawBitmap::SetOrientation(TOrientation aOrientation)
{
if (iOrientation == aOrientation)
return ETrue;
return EFalse;
}
void CDrawBitmap::SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap)
{
iFadeMapFactor = aWhiteMap - aBlackMap + 1;
iFadeMapOffset = aBlackMap;
}
TRgb CDrawBitmap::FadeRgb(TRgb aColor)
{
TInt value = aColor.Internal();
TInt b = (((value & 0x000000ff) * iFadeMapFactor) >> 8) + iFadeMapOffset;
TInt g = (((value & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset;
//the multiplication by iFadeMapFactor can overflow into the sign bit, so we shift down in two steps
TInt r = ((((value & 0x00ff0000) >> 16) * iFadeMapFactor) >> 8) + iFadeMapOffset;
TInt a = aColor.Alpha();
return TRgb(r,g,b,a);
}
TUint32 CDrawBitmap::FadeRgb(TUint32 aColor)
{
TInt value = aColor;
TInt b = (((value & 0x000000ff) * iFadeMapFactor) >> 8) + iFadeMapOffset;
TInt g = (((value & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset;
//the multiplication by iFadeMapFactor can overflow into the sign bit, so we shift down in two steps
TInt r = ((((value & 0x00ff0000) >> 16) * iFadeMapFactor) >> 8) + iFadeMapOffset;
TInt a = aColor >> 24;
return (a<<24) | ((r&0xff)<<16) | ((g&0xff)<<8) | (b&0xff);
}
/**
The overloaded function for FadeRgb(TRgb) which works directly with
the Red, Green and Blue colour components to increase the performance.
@param aRed Red component of colour.
@param aGreen Green component of colour.
@param aBlue Blue component of colour.
*/
void CDrawBitmap::FadeRgb(TInt& aRed, TInt& aGreen, TInt& aBlue)
{
aRed = ((aRed * iFadeMapFactor) >> 8) + iFadeMapOffset;
aGreen = ((aGreen * iFadeMapFactor) >> 8) + iFadeMapOffset;
aBlue = ((aBlue * iFadeMapFactor) >> 8) + iFadeMapOffset;
}
TUint8 CDrawBitmap::FadeGray(TInt aGray256)
{
return STATIC_CAST(TUint8,((aGray256 * iFadeMapFactor) >> 8) + iFadeMapOffset);
}
//aX and aY - logical coordinates
//aX and aY - deorientated and transformed to physical coordinates after the call
void CDrawBitmap::DeOrientate(TInt& aX,TInt& aY) const
{
register TInt physWidth = iSize.iWidth;
register TInt physHeight = iSize.iHeight;
register TInt originX = iOrigin.iX;
register TInt originY = iOrigin.iY;
register TInt scalingFactorX = iScalingSettings.iFactorX;
register TInt scalingFactorY = iScalingSettings.iFactorY;
if(iOrientation & 0x1)
{
aX = ::Log2Phys(aX, originX, scalingFactorY, physHeight);
aY = ::Log2Phys(aY, originY, scalingFactorX, physWidth);
}
else
{
aX = ::Log2Phys(aX, originX, scalingFactorX, physWidth);
aY = ::Log2Phys(aY, originY, scalingFactorY, physHeight);
}
//aX and aY - descaled.
switch(iOrientation)
{
case EOrientationNormal:
{
return;
}
case EOrientationRotated180:
{
aX = physWidth - aX - 1;
aY = physHeight - aY - 1;
break;
}
case EOrientationRotated90:
{
TInt temp = physWidth - aY - 1;
aY = aX;
aX = temp;
break;
}
default: // EOrientationRotated270
{
TInt temp = aY;
aY = physHeight - aX - 1;
aX = temp;
}
}
}
//aPoint - logical coordinates
//The method returns TPoint object with deorientated and transformed to physical coordinates.
TPoint CDrawBitmap::DeOrientate(const TPoint& aPoint) const
{
register TInt physWidth = iSize.iWidth;
register TInt physHeight = iSize.iHeight;
register TInt originX = iOrigin.iX;
register TInt originY = iOrigin.iY;
register TInt scalingFactorX = iScalingSettings.iFactorX;
register TInt scalingFactorY = iScalingSettings.iFactorY;
TPoint physPt;
if(iOrientation & 0x1)
{
physPt.iX = ::Log2Phys(aPoint.iX, originX, scalingFactorY, physHeight);
physPt.iY = ::Log2Phys(aPoint.iY, originY, scalingFactorX, physWidth);
}
else
{
physPt.iX = ::Log2Phys(aPoint.iX, originX, scalingFactorX, physWidth);
physPt.iY = ::Log2Phys(aPoint.iY, originY, scalingFactorY, physHeight);
}
//physPt - descaled
switch(iOrientation)
{
case EOrientationNormal:
{
return physPt;
}
case EOrientationRotated180:
{
return TPoint(physWidth - physPt.iX - 1, physHeight - physPt.iY - 1);
}
case EOrientationRotated90:
{
return TPoint(physWidth - physPt.iY - 1, physPt.iX);
}
// EOrientationRotated270
default:
return TPoint(physPt.iY, physHeight - physPt.iX - 1);
}
}
//aRect - logical coordinates
//The method returns TRect object with deorientated and transformed to physical coordinates.
TRect CDrawBitmap::DeOrientate(const TRect& aRect) const
{
register TInt originX = iOrigin.iX;
register TInt originY = iOrigin.iY;
register TInt scalingFactorX = iScalingSettings.iFactorX;
register TInt scalingFactorY = iScalingSettings.iFactorY;
register TInt physWidth = iSize.iWidth;
register TInt physHeight = iSize.iHeight;
TRect physRect;
if(iOrientation & 0x1)
{
physRect.iTl.iX = ::Log2Phys(aRect.iTl.iX, originX, scalingFactorY, physHeight);
physRect.iTl.iY = ::Log2Phys(aRect.iTl.iY, originY, scalingFactorX, physWidth);
physRect.iBr.iX = ::RBtmLog2Phys(aRect.iBr.iX, originX, scalingFactorY, physHeight);
physRect.iBr.iY = ::RBtmLog2Phys(aRect.iBr.iY, originY, scalingFactorX, physWidth);
}
else
{
physRect.iTl.iX = ::Log2Phys(aRect.iTl.iX, originX, scalingFactorX, physWidth);
physRect.iTl.iY = ::Log2Phys(aRect.iTl.iY, originY, scalingFactorY, physHeight);
physRect.iBr.iX = ::RBtmLog2Phys(aRect.iBr.iX, originX, scalingFactorX, physWidth);
physRect.iBr.iY = ::RBtmLog2Phys(aRect.iBr.iY, originY, scalingFactorY, physHeight);
}
//physRect - descaled
if(iOrientation == EOrientationNormal)
{
return physRect;
}
if (iOrientation == EOrientationRotated180)
{
return TRect(TPoint(physWidth - physRect.iBr.iX, physHeight - physRect.iBr.iY), physRect.Size());
}
TSize altSize(physRect.Height(), physRect.Width());
TPoint altPoint;
if (iOrientation == EOrientationRotated90)
{
altPoint.SetXY(physWidth - physRect.iBr.iY, physRect.iTl.iX);
}
else // EOrientationRotated270
{
altPoint.SetXY(physRect.iTl.iY, physHeight - physRect.iBr.iX);
}
return TRect(altPoint, altSize);
}
//aX and aY - logical coordinates
TRgb CDrawBitmap::ReadPixel(TInt aX,TInt aY) const
{
DeOrientate(aX, aY);//aX and aY - physical coordinates
__ASSERT_DEBUG(aX >= 0 && aX < iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY >= 0 && aY < iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
return ReadRgbNormal(aX, aY);
}
//aX and aY - logical coordinates
void CDrawBitmap::ReadLine(TInt aX,TInt aY,TInt aLength,
TAny* aBuffer,TDisplayMode aDispMode) const
{
DeOrientate(aX,aY);//aX and aY - physical coordinates
__ASSERT_DEBUG(aX >= 0 && aX < iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY >= 0 && aY < iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
#if defined(_DEBUG)
switch (iOrientation)
{
case EOrientationNormal:
__ASSERT_DEBUG(aX + aLength <= iLongWidth,Panic(EScreenDriverPanicOutOfBounds));
break;
case EOrientationRotated90:
__ASSERT_DEBUG(aY + aLength <= iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
break;
case EOrientationRotated180:
__ASSERT_DEBUG(aX - aLength >= -1,Panic(EScreenDriverPanicOutOfBounds));
break;
default: // EOrientationRotated270
__ASSERT_DEBUG(aY - aLength >= -1,Panic(EScreenDriverPanicOutOfBounds));
break;
}
#endif
__ASSERT_DEBUG(aLength > 0,Panic(EScreenDriverPanicZeroLength));
__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));
if (aDispMode == iDispMode)
{
ReadLine(aX,aY,aLength,aBuffer);
return;
}
TInt xInc = xIncArray[iOrientation];
TInt yInc = yIncArray[iOrientation];
if(iOrientation & 0x1)
{
xInc*=iScalingSettings.iFactorY;
yInc*=iScalingSettings.iFactorX;
}
else
{
xInc*=iScalingSettings.iFactorX;
yInc*=iScalingSettings.iFactorY;
}
switch (aDispMode)
{
case EGray2:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
while (aLength >= 8)
{
bufferPtr[0] = TUint8(ReadRgbNormal(aX,aY)._Gray2());
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 1);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 2);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 3);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 4);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 5);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 6);
aX += xInc; aY += yInc;
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << 7);
aX += xInc; aY += yInc;
bufferPtr++;
aLength -= 8;
}
TInt bitShift = 0;
TInt bitLimit = aLength;
if (bitShift < bitLimit)
bufferPtr[0] = 0;
while (bitShift < bitLimit)
{
bufferPtr[0] |= TUint8(ReadRgbNormal(aX,aY)._Gray2() << bitShift);
aX += xInc; aY += yInc;
bitShift++;
}
}
break;
case EGray4:
{
TUint8* bufferPtr = REINTERPRET_CAST(TUint8*,aBuffer);
while (aLength > 3)
{
*bufferPtr = TUint8(ReadRgbNormal(aX,aY)._Gray4());
aX += xInc; aY += yInc;
*bufferPtr |= TUint8(ReadRgbNormal(aX,aY)._Gray4() << 2);
aX += xInc; aY += yInc;
*bufferPtr |= TUint8(ReadRgbNormal(aX,aY)._Gray4() << 4);
aX += xInc; aY += yInc;
*bufferPtr++ |= TUint8(ReadRgbNormal(aX,aY)._Gray4() << 6);
aX += xInc; aY += yInc;
aLength -= 4;
}
if (aLength > 0)
{
*bufferPtr = TUint8(ReadRgbNormal(aX,aY)._Gray4());
aX += xInc; aY += yInc;
aLength--;
}
if (aLength > 0)
{
*bufferPtr |= TUint8(ReadRgbNormal(aX,aY)._Gray4() << 2);
aX += xInc; aY += yInc;
aLength--;
}
if (aLength > 0)
*bufferPtr |= TUint8(ReadRgbNormal(aX,aY)._Gray4() << 4);
}
break;
case EGray16:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
while (aLength > 1)
{
*bufferPtr = TUint8(ReadRgbNormal(aX,aY)._Gray16());
aX += xInc; aY += yInc;
*bufferPtr++ |= TUint8(ReadRgbNormal(aX,aY)._Gray16() << 4);
aX += xInc; aY += yInc;
aLength -= 2;
}
if (aLength > 0)
*bufferPtr = TUint8(ReadRgbNormal(aX,aY)._Gray16());
}
break;
case EGray256:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
const TUint8* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = TUint8(ReadRgbNormal(aX,aY)._Gray256());
aX += xInc; aY += yInc;
}
}
break;
case EColor16:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
while (aLength > 1)
{
*bufferPtr = TUint8(ReadRgbNormal(aX,aY).Color16());
aX += xInc; aY += yInc;
*bufferPtr++ |= TUint8(ReadRgbNormal(aX,aY).Color16() << 4);
aX += xInc; aY += yInc;
aLength -= 2;
}
if (aLength > 0)
*bufferPtr = TUint8(ReadRgbNormal(aX,aY).Color16());
}
break;
case EColor256:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
const TUint8* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = TUint8(ReadRgbNormal(aX,aY).Color256());
aX += xInc; aY += yInc;
}
}
break;
case EColor4K:
{
TUint16* bufferPtr = (TUint16*)aBuffer;
const TUint16* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = TUint16(ReadRgbNormal(aX,aY)._Color4K());
aX += xInc; aY += yInc;
}
}
break;
case EColor64K:
{
TUint16* bufferPtr = (TUint16*)aBuffer;
const TUint16* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = TUint16(ReadRgbNormal(aX,aY)._Color64K());
aX += xInc; aY += yInc;
}
}
break;
case EColor16M:
{
TUint8* bufferPtr = (TUint8*)aBuffer;
const TUint8* bufferPtrLimit = bufferPtr + (aLength * 3);
while (bufferPtr < bufferPtrLimit)
{
TUint32 pixelColorValue = ReadRgbNormal(aX,aY).Internal();
aX += xInc; aY += yInc;
bufferPtr[0] = TUint8(pixelColorValue);
bufferPtr[1] = TUint8(pixelColorValue >> 8);
bufferPtr[2] = TUint8(pixelColorValue >> 16);
bufferPtr += 3;
}
}
break;
case ERgb:
{
TRgb* bufferPtr = (TRgb*)aBuffer;
const TRgb* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = ReadRgbNormal(aX,aY);
aX += xInc; aY += yInc;
}
}
break;
case EColor16MU:
{
TUint32* bufferPtr = (TUint32*)aBuffer;
const TUint32* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = ReadRgbNormal(aX,aY)._Color16MU();//BGRA (Blue/Green/Red/Alpha) as little endian bite order
aX += xInc; aY += yInc;
}
}
break;
case EColor16MA:
{
TUint32* bufferPtr = (TUint32*)aBuffer;
const TUint32* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = ReadRgbNormal(aX,aY)._Color16MA();//BGRA (Blue/Green/Red/Alpha) as little endian bite order
aX += xInc; aY += yInc;
}
}
break;
case EColor16MAP:
{
TUint32* bufferPtr = (TUint32*)aBuffer;
const TUint32* bufferPtrLimit = bufferPtr + aLength;
while (bufferPtr < bufferPtrLimit)
{
*bufferPtr++ = ReadRgbNormal(aX,aY)._Color16MAP();;
aX += xInc; aY += yInc;
}
}
break;
default:
Panic(EScreenDriverPanicInvalidDisplayMode);
}
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteRgb(TInt aX,TInt aY,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)
{
register TInt width = -1;
register TInt height = -1;
PreWriteRgb(width, height, aX, aY, aDrawMode);
WriteRgb(width, height, aX, aY, aColor, aDrawMode);
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,
TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)
{
const TRect rect = DeOrientate(TRect(aX,aY,aX + aLength,aY + aHeight));//rect - physical coordinates
aX = rect.iTl.iX;
aY = rect.iTl.iY;
aLength = rect.Width();
aHeight = rect.Height();
__ASSERT_DEBUG(aX>=0 && aX+aLength<=iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY>=0 && aY+aHeight<=iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
MapColorToUserDisplayMode(aColor);
if(iShadowMode)
{
Shadow(aColor);
}
if(aDrawMode&CGraphicsContext::EInvertPen)
{
aColor=~aColor;
}
if(aDrawMode&CGraphicsContext::EPenmode)
{
BlendRgbMulti(aX,aY,aLength,aHeight,aColor);
return;
}
if(aDrawMode&CGraphicsContext::EWriteAlpha)
{
WriteRgbMulti(aX,aY,aLength,aHeight,aColor);
return;
}
if(aDrawMode&CGraphicsContext::EInvertScreen)
{
WriteRgbMultiXOR(aX,aY,aLength,aHeight,KRgbWhite);
}
if(aDrawMode&CGraphicsContext::EXor)
{
WriteRgbMultiXOR(aX,aY,aLength,aHeight,aColor);
}
else if(aDrawMode&CGraphicsContext::EAnd)
{
WriteRgbMultiAND(aX,aY,aLength,aHeight,aColor);
}
else if(aDrawMode&CGraphicsContext::EOr)
{
WriteRgbMultiOR(aX,aY,aLength,aHeight,aColor);
}
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,
TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)
{
TRect drawRect;
GetDrawRect(drawRect);
__ASSERT_DEBUG(aX >= drawRect.iTl.iX && (aX + aLength) <= drawRect.iBr.iX, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY >= drawRect.iTl.iY && (aY + aHeight) <= drawRect.iBr.iY, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aBuffer, Panic(EScreenDriverPanicNullPointer));
__ASSERT_DEBUG(aLength > 0, Panic(EScreenDriverPanicZeroLength));
__ASSERT_DEBUG(aLength <= 32, Panic(EScreenDriverPanicOutOfBounds));
MapColorToUserDisplayMode(aColor);
if(iShadowMode)
Shadow(aColor);
if(aDrawMode&CGraphicsContext::EInvertPen)
aColor=~aColor;
if(aDrawMode&CGraphicsContext::EPenmode)
{
WriteBinary(aX,aY,aBuffer,aLength,aHeight,aColor);
return;
}
if(aDrawMode&CGraphicsContext::EInvertScreen)
WriteBinaryOp(aX,aY,aBuffer,aLength,aHeight,KRgbWhite,CGraphicsContext::EDrawModeXOR);
if(aDrawMode&CGraphicsContext::ELogicalOp)
WriteBinaryOp(aX,aY,aBuffer,aLength,aHeight,aColor,(CGraphicsContext::TDrawMode)(aDrawMode&CGraphicsContext::ELogicalOp));
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteBinaryLine(TInt aX,TInt aY,TUint32* aBuffer,
TInt aLength,TRgb aColor,
CGraphicsContext::TDrawMode aDrawMode)
{
MapColorToUserDisplayMode(aColor);
while(aLength>32)
{
WriteBinary(aX,aY,aBuffer,32,1,aColor,aDrawMode);
aX+=32;
aBuffer++;
aLength-=32;
}
WriteBinary(aX,aY,aBuffer,aLength,1,aColor,aDrawMode);
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,
TInt aHeight,TRgb aColor,
CGraphicsContext::TDrawMode aDrawMode,TBool aUp)
{
TRect drawRect;
GetDrawRect(drawRect);
__ASSERT_DEBUG(aX >= drawRect.iTl.iX && aX < drawRect.iBr.iX, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY >= drawRect.iTl.iY, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aUp || (aY + aHeight) <= drawRect.iBr.iY, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(!aUp || (aY - aHeight + 1) >= drawRect.iTl.iY, Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aBuffer, Panic(EScreenDriverPanicNullPointer));
__ASSERT_DEBUG(aHeight > 0, Panic(EScreenDriverPanicZeroLength));
MapColorToUserDisplayMode(aColor);
if((aDrawMode & CGraphicsContext::EPenmode) && iScalingOff)
{
if(iShadowMode)
Shadow(aColor);
if(aDrawMode&CGraphicsContext::EInvertPen)
aColor=~aColor;
WriteBinaryLineVertical(aX,aY,aBuffer,aHeight,aColor,aUp);
return;
}
TUint32 mask = 1;
TUint32 data = *aBuffer++;
TInt endrow = aY + (aUp ? -aHeight : aHeight);
TInt rowInc = aUp ? -1 : 1;
while (aY != endrow)
{
if (!mask)
{
data = *aBuffer++;
mask = 1;
}
if (data & mask)
{
WriteRgb(aX, aY, aColor, aDrawMode);
}
aY += rowInc;
mask <<= 1;
}
}
//aX, aY - logical coordinates
void CDrawBitmap::WriteLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer,
CGraphicsContext::TDrawMode aDrawMode)
{
const TPoint originalPoint(aX,aY);
DeOrientate(aX,aY);//aX and aY - physical coordinates
__ASSERT_DEBUG(aX >= 0,Panic(EScreenDriverPanicOutOfBounds));
__ASSERT_DEBUG(aY >= 0,Panic(EScreenDriverPanicOutOfBounds));
#if defined(_DEBUG)
switch (iOrientation)
{
case EOrientationNormal:
__ASSERT_DEBUG(aX + aLength <= iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));
break;
case EOrientationRotated90:
__ASSERT_DEBUG(aY + aLength <= iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));
break;
case EOrientationRotated180:
__ASSERT_DEBUG(aX - aLength >= -1,Panic(EScreenDriverPanicOutOfBounds));
break;
default: // EOrientationRotated270
__ASSERT_DEBUG(aY - aLength >= -1,Panic(EScreenDriverPanicOutOfBounds));
break;
}
#endif
__ASSERT_DEBUG(aLength > 0,Panic(EScreenDriverPanicZeroLength));
__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));
MapBufferToUserDisplayMode(aLength,aBuffer);
if(iShadowMode)
{
ShadowBuffer(aLength,aBuffer);
}
if(aDrawMode&CGraphicsContext::EInvertPen)
{
InvertBuffer(aLength,aBuffer);
}
if(aDrawMode&CGraphicsContext::EPenmode)
{
BlendLine(aX,aY,aLength,aBuffer);
return;
}
if(aDrawMode&CGraphicsContext::EWriteAlpha)
{
WriteLine(aX,aY,aLength,aBuffer);
return;
}
if(aDrawMode&CGraphicsContext::EInvertScreen)
{
const TRect rect = DeOrientate(TRect(originalPoint,TSize(aLength,1)));//"rect" - deorientated and scaled
WriteRgbMultiXOR(rect.iTl.iX,rect.iTl.iY,rect.Width(),rect.Height(),KRgbWhite);
}
if(aDrawMode&CGraphicsContext::EXor)
{
WriteLineXOR(aX,aY,aLength,aBuffer);
}
else if(aDrawMode&CGraphicsContext::EAnd)
{
WriteLineAND(aX,aY,aLength,aBuffer);
}
else if(aDrawMode&CGraphicsContext::EOr)
{
WriteLineOR(aX,aY,aLength,aBuffer);
}
}
TAny* CDrawBitmap::CopyOffset(TAny* aDestination,const TAny* aSource,TInt aWordsToCopy,TInt aSourceBitOffset)
{
ASSERT(aSourceBitOffset > 0 && aSourceBitOffset < 32);
const TUint32* srcPtr = REINTERPRET_CAST(const TUint32*,aSource);
TUint32* destPtr = REINTERPRET_CAST(TUint32*,aDestination);
const TUint32* destPtrLimit = destPtr + aWordsToCopy;
const TInt sourceBitOffsetComplement = 32 - aSourceBitOffset;
TUint32 sourceValue = *srcPtr++;
while (destPtr < destPtrLimit)
{
TUint32 destValue = sourceValue >> aSourceBitOffset;
sourceValue = *srcPtr++;
destValue |= sourceValue << sourceBitOffsetComplement;
*destPtr++ = destValue;
}
return destPtr;
}
/** Common code to read a line of pixels where there are >1 pixels per byte.
The source words must be shifted to fit the target buffer.
@param aPixelPtr Source location to start copying from (word aligned, last word is safe)
@param aBufferPtr Target location to write to (word aligned - may or may not own all last word)
@param aWordsCnt Number of source words that can be safely copied
@param aRestPixels Number of pixels that must be read from the next word for the final byte copy
@param aBytesCount Number of bytes to write from final input word
@param aShiftBits Number of bits shifted between input and output words.
**/
void CDrawBitmap::ReadLineCommon(TUint32* aPixelPtr,TUint32* aBufferPtr,TInt aWordsCount,TInt aRestPixels,TInt aBytesCount,TInt aShiftBits)
{
// As many pixels as possible are copied by shifting whole words.
// This involves reading two source words, shifting them,
// and merging the result to one target word.
// However, two cases mean the last few pixels need to be treated carefully:
// 1) The target buffer may be a number of bytes, not whole words.
// The number of pixels to copy defines the number of bytes to copy.
// 2) The number of pixels to read may mean the last read does not need
// to read a second word in order to satisfy the number of pixels requested.
// This next word may not be mapped, so must not be read!
//Are we willing to pay for these asserts for every scanline copy, even in debug?
__ASSERT_DEBUG(aPixelPtr, User::Invariant());
__ASSERT_DEBUG(aBufferPtr, User::Invariant());
__ASSERT_DEBUG(aWordsCount>=0, User::Invariant());
__ASSERT_DEBUG(aBytesCount<5, User::Invariant());
__ASSERT_DEBUG(aShiftBits>=0 && aShiftBits<33, User::Invariant());
TUint32 nextpixel;
if(aWordsCount>0)
{
if (aShiftBits==0)
{
while (aWordsCount--)
{
*aBufferPtr++ = *aPixelPtr++;
}
if (aBytesCount>0) //I hope the optimiser can concatenate these two tests?
{
nextpixel=aPixelPtr[0];
}
}
else
{
const TInt shiftBitsExtra = 32 - aShiftBits;
nextpixel=aPixelPtr[0];
while (aWordsCount--)
{
TUint32 prevpixel=nextpixel;
nextpixel=aPixelPtr[1]; //this must not read forward when it doesn't need to
aBufferPtr[0] = (prevpixel >> aShiftBits) | (nextpixel << shiftBitsExtra);
aPixelPtr++;
aBufferPtr++;
}
}
}
else
{
nextpixel=aPixelPtr[0];
}
//deal with the trailing bytes
if (aBytesCount>0)
{
if (aBytesCount==4)
{
//The client only requests 4 bytes rather than 1 more word when the requested pixels
//mean the second word should not be read from.
//Can also write the result in a single operation!
aBufferPtr[0]=nextpixel>> aShiftBits;
}
else
{
if (aRestPixels>0)
{
//do need to read from next word to fill all the requested pixels.
aWordsCount=(nextpixel >> aShiftBits) | (aPixelPtr[1] << (32 - aShiftBits));
}
else
{
//Don't read second word, otherwise might read past end of picture data!
aWordsCount=(nextpixel >> aShiftBits);
}
TUint8* bufferPtrChar=reinterpret_cast <TUint8*> (aBufferPtr);
//max 3 bytes to store
if (aBytesCount&2)
{
bufferPtrChar[0]=aWordsCount;
bufferPtrChar[1]=aWordsCount>>8;
bufferPtrChar+=2;
aWordsCount>>=16;
}
if (aBytesCount&1)
{
bufferPtrChar[0]=aWordsCount;
}
}
}
}
/**
The method performs an alpha blending of the source data - aRgbBuffer and screen pixels, using
the data from aMaskBuffer buffer as an alpha blending factor.
If the shadowing/fading flag is set, a shadow/fade copy of the source bitmap will be used.
The formula used for that, is:
(C1 * A + C2 * (255 - A)) / 255, where:
- C1 - a pixel from aRgbBuffer;
- C2 - a pixel from the sceen;
- A - a pixel from aMaskBuffer;
The content of source and mask buffers is preserved.
The calculated alpha blended pixel is written to the destination - the screen or a bitmap.
@param aX Logical X coordinate of the position in the target the result should be drawn to.
@param aY Logical Y coordinate of the position in the target the result should be drawn to.
@param aLength Source data - length in pixels.
@param aRgbBuffer A pointer to a line of the source bitmap data.
@param aMaskBuffer Buffer containing the data which should be used as an
alpha blending factor.
*/
void CDrawBitmap::WriteRgbAlphaLine(TInt aX, TInt aY, TInt aLength,
TUint8* aRgbBuffer, TUint8* aMaskBuffer,
CGraphicsContext::TDrawMode aDrawMode)
{
iAlphaBlend->WriteRgbAlphaLine(aX, aY, aLength, aRgbBuffer, aMaskBuffer,
MAlphaBlend::EShdwBefore,
aDrawMode);
}
/**
The method performs an alpha blending of the source data - aRgbBuffer1 and aBuffer2, using
the data from aMaskBuffer buffer as an alpha blending factor.
If the shadowing/fading flag is set, the resulting pixels will be shadowed/faded.
The formula used for that, is:
(C1 * A + C2 * (255 - A)) / 255, where:
- C1 - a pixel from aRgbBuffer1;
- C2 - a pixel from aBuffer2;
- A - a pixel from aMaskBuffer;
The content of source and mask buffers is preserved.
The calculated alpha blended pixel is written to the destination - the screen or a bitmap.
@param aX Logical X coordinate of the position in the target the result should be drawn to.
@param aY Logical Y coordinate of the position in the target the result should be drawn to.
@param aLength Source data - length in pixels.
@param aRgbBuffer1 A pointer to a line of the source bitmap data 1.
@param aBuffer2 A pointer to a line of the source bitmap data 2.
Source bitmap data 2 should be mapped to current display mode
before the method call.
@param aMaskBuffer Buffer containing the data which should be used as an
alpha blending factor.
@param aDrawMode Drawing mode
*/
void CDrawBitmap::WriteRgbAlphaLine(TInt aX,TInt aY,TInt aLength,
const TUint8* aRgbBuffer1,
const TUint8* aBuffer2,
const TUint8* aMaskBuffer,
CGraphicsContext::TDrawMode aDrawMode)
{
// Save current shadow mode
TShadowMode temp_mode = iShadowMode;
iShadowMode = ENoShadow;
// copy the source data 2 to the screen/bitmap target buffer
WriteLine(aX, aY, aLength, (TUint32*)aBuffer2, aDrawMode);
// restore current shadow mode
iShadowMode = temp_mode;
// DrawModePen is the only supported operation for blending masks.
iAlphaBlend->WriteRgbAlphaLine(aX, aY, aLength, aRgbBuffer1, aMaskBuffer,
MAlphaBlend::EShdwAfter, CGraphicsContext::EDrawModePEN);
}
//Initializes iSize and iDrawRect data members.
//It should be called every time when iSize is going to be changed - Construct() implementations
//in derived classes.
//The method does not use iOrientation data member.
//@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 CDrawBitmap::SetSize(const TSize& aSize)
{
iSize = aSize;
InitLogicalCoordinates();
}
/**
The method swaps bitmap device's width and height.
For example: if the size is (40, 20), the swapped size will be (20, 40).
The device's content is not preserved.
The method leaves CDrawBitmap object in a consistent state -
scaling settings will be set with their default values (the scaling is switched off),
iDitherOrigin will be set to (0,0), iOrigin to (0,0).
Note: This method is used internally by BITGDI component. Do not call it!
*/
void CDrawBitmap::SwapWidthAndHeight()
{
SetDefaults();
//Swap width and height
TSize swappedSize(iSize.iHeight, iSize.iWidth);
//Initialize iSize, iScanLineWords, iLongWidth data members.
SetSize(swappedSize);
}
//This method initializes some of the data members.
//Espetially it switches scaling off, sets iDitherOrigin to (0,0),
//iOrigin to (0,0), iDrawRect to (0,0,0,0). iSize value is preserved.
//Do not forget to update it if adding new data members!
void CDrawBitmap::SetDefaults()
{
iLongWidth = 0;
iDitherOrigin.SetXY(0, 0);
iFadeMapFactor = 128;
iFadeMapOffset = 128;
iScalingSettings = TScalingSettings();
iOrigin.SetXY(0, 0);
iScalingOff = ETrue;
iOriginIsZero = ETrue;
iDrawRect.SetRect(0, 0, 0, 0);
}
/**
Implementation for CFbsDrawDevice::GetInterface().
Retrieves a pointer to a specified interface of CFbsDrawDevice implementation.
@param aInterfaceId Interface identifier of the interface to be retrieved.
@param aInterface Address of variable that retrieves the specified interface.
@return KErrNone If the interface is supported, KErrNotSupported otherwise.
*/
TInt CDrawBitmap::GetInterface(TInt aInterfaceId, TAny*& aInterface)
{
aInterface = NULL;
TInt err = KErrNotSupported;
switch (aInterfaceId)
{
case KScalingSettingsInterfaceID:
{
if(CanBeScaled())
{
aInterface = static_cast <MScalingSettings*> (this);
err = KErrNone;
}
break;
}
case KDrawDeviceOriginInterfaceID:
{
if(CanOriginBeMoved())
{
aInterface = static_cast <MDrawDeviceOrigin*> (this);
err = KErrNone;
}
break;
}
case KAlphaBlendInterfaceID:
{
aInterface = static_cast <MAlphaBlend*> (this);
err = KErrNone;
break;
}
case KOrientationInterfaceID:
{
aInterface = static_cast <MDrawDeviceOrientation*> (this);
err = KErrNone;
break;
}
case KOutlineAndShadowInterfaceID:
{
aInterface = static_cast <MOutlineAndShadowBlend*> (this);
err = KErrNone;
break;
}
case KFastBlendInterfaceID:
{
aInterface = static_cast <MFastBlend*> (this);
err = KErrNone;
break;
}
}
return err;
}
void CDrawBitmap::BlendRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)
{
WriteRgbMulti(aX,aY,aLength,aHeight,aColor);
}
void CDrawBitmap::BlendLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)
{
WriteLine(aX, aY,aLength, aBuffer);
}
/**
Convert a RGB pixel into the color associated to the user display mode.
@param aRed red color
@param aGreen green color
@param aBlue blue color
@internalComponent
*/
void CDrawBitmap::MapColorToUserDisplayMode(TInt& aRed,TInt& aGreen,TInt& aBlue)
{
TUint32 tmpValue;
switch (iUserDispMode)
{
case EGray2:
tmpValue = ((aRed<<1) + aGreen + (aGreen<<2) + aBlue) >> 10;
if (tmpValue) { aRed = 0xff; aBlue = 0xff; aGreen = 0xff; }
else { aRed = 0x00; aBlue = 0x00; aGreen = 0x00; }
break;
case EGray4:
tmpValue = ((aRed<<1) + aGreen + (aGreen<<2) + aBlue) >> 9;
tmpValue = tmpValue | (tmpValue << 2) | (tmpValue << 4) | (tmpValue << 6);
aRed = tmpValue; aGreen = tmpValue; aBlue = tmpValue;
break;
case EGray16:
tmpValue = ((aRed<<1) + aGreen + (aGreen<<2) + aBlue) >> 7;
tmpValue = tmpValue | (tmpValue << 4);
aRed = tmpValue; aGreen = tmpValue; aBlue = tmpValue;
break;
case EGray256:
tmpValue = ((aRed<<1) + aGreen + (aGreen<<2) + aBlue) >> 3;
aRed = tmpValue; aGreen = tmpValue; aBlue = tmpValue;
break;
case EColor16:
{
TRgb aColor(aRed,aGreen,aBlue);
aColor = TRgb::Color16(aColor.Color16());
aRed = aColor.Red(); aGreen = aColor.Green(); aBlue = aColor.Blue();
break;
}
case EColor256:
{
TRgb aColor2(aRed,aGreen,aBlue);
aColor2 = TRgb::Color256(aColor2.Color256());
aRed = aColor2.Red(); aGreen = aColor2.Green(); aBlue = aColor2.Blue();
break;
}
case EColor4K:
aBlue = aBlue & 0xf0; aBlue |= (aBlue >> 4);
aGreen = aGreen & 0xf0; aGreen |= (aGreen >> 4);
aRed = aRed & 0xf0; aRed |= (aRed >> 4);
break;
case EColor64K:
aBlue = aBlue & 0xf8; aBlue += (aBlue >> 5);
aGreen = aGreen & 0xfc; aGreen += (aGreen >> 6);
aRed = aRed & 0xf8; aRed += (aRed >> 5);
break;
default:
break;
}
}
/**
CDrawBitmap::Orientation() implementation.
@internalTechnology
@see MDrawDeviceOrientation::Orientation()
*/
CFbsDrawDevice::TOrientation CDrawBitmap::Orientation()
{
return iOrientation;
}
#ifdef __ARMCC__
#ifndef __MARM_THUMB__
#define USE_SCREENDRIVER_ARM_ASM
#endif //__MARM_THUMB__
#endif //__ARMCC__
#ifdef USE_SCREENDRIVER_ARM_ASM
/**
MemFill - using an unrolled loop to perform the following:
for (TUint32* tempWordPtr = wordPtr; tempWordPtr < wordPtrLimit; tempWordPtr++)
{
*tempWordPtr = colorWord;
}
*/
__asm void MemFillTUint32(TUint32* /*aTrg*/, TInt /*aLength*/, const TUint32 /*aValue*/)
{
//r0 - aTrg, r1 - aLength, r2 - aValue
push {r1,r3,lr}
and r3,r1,#7
cmp r3,#7
addls pc,pc,r3,LSL #2
b mf_switch0
b mf_switch0
b mf_switch1
b mf_switch2
b mf_switch3
b mf_switch4
b mf_switch5
b mf_switch6
b mf_switch7
mf_switch7
str r2,[r0],#4
mf_switch6
str r2,[r0],#4
mf_switch5
str r2,[r0],#4
mf_switch4
str r2,[r0],#4
mf_switch3
str r2,[r0],#4
mf_switch2
str r2,[r0],#4
mf_switch1
str r2,[r0],#4
mf_switch0
asr r1,r1,#3
cmp r1,#0
beq mf_complete
push {r0,r2,r4-r8}
mov r3,r2
mov r4,r2
mov r5,r2
mov r6,r2
mov r7,r2
mov r8,r2
mov lr,r2
mf_more
stmia r0!,{r2-r8,lr}
subs r1,r1,#1
bgt mf_more
pop {r0,r2,r4-r8}
mf_complete
pop {r1,r3,pc}
}
#else //USE_SCREENDRIVER_ARM_ASM
const TInt KDevideByEightShift = 3;
const TInt KModulusByEightFlag = 7;
void MemFillTUint32(TUint32* tempWordPtr, TInt aCount, const TUint32 aValue)
{
TInt remainder = aCount & KModulusByEightFlag;
switch (remainder)
{
case 7:
*tempWordPtr++ = aValue;
case 6:
*tempWordPtr++ = aValue;
case 5:
*tempWordPtr++ = aValue;
case 4:
*tempWordPtr++ = aValue;
case 3:
*tempWordPtr++ = aValue;
case 2:
*tempWordPtr++ = aValue;
case 1:
*tempWordPtr++ = aValue;
}
register TUint32 value0 = aValue;
register TUint32 value1 = aValue;
register TUint32 value2 = aValue;
for(TInt times = (aCount >> KDevideByEightShift); times > 0; --times)
{
*tempWordPtr++ = value0;
*tempWordPtr++ = value1;
*tempWordPtr++ = value2;
*tempWordPtr++ = aValue;
*tempWordPtr++ = value0;
*tempWordPtr++ = value1;
*tempWordPtr++ = value2;
*tempWordPtr++ = aValue;
}
}
#endif //USE_SCREENDRIVER_ARM_ASM