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