// 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 <bitdev.h>

 #include <bitdraw.h>

 #include <bitdrawscaling.h>

 #include <bitdrawinterfaceid.h>

 #include "BITPANIC.H"

 const TInt KMaxPixelSize = KMaxTInt / 4; // Maximum pixel size to avoid some overflow problems

 CFbsBitmapDevice::CFbsBitmapDevice():

 	CFbsDevice()

 	{}

 /** Frees all resources owned by the object prior to its destruction. */

 EXPORT_C CFbsBitmapDevice::~CFbsBitmapDevice()

 	{

 	delete iFbsBmp;

 	}

 /** Constructs the object from the specified Font and Bitmap server

 managed bitmap.

 @param aFbsBitmap A pointer to a Font and Bitmap server managed bitmap.

 @param aLibname Name of the library to create the low-level CFbsDrawDevice 

 object from.

 @return A pointer to the newly constructed graphics device. */

 EXPORT_C CFbsBitmapDevice* CFbsBitmapDevice::NewL(CFbsBitmap* aFbsBitmap,

 												  const TDesC& /*aLibname*/)

     {

 	return CFbsBitmapDevice::NewL(aFbsBitmap);

 	}

 /** Allocates and constructs the device with the bitmap. Also creates a 2D graphics 

 accelerator which is owned and used by the device.

 @param aFbsBitmap A pointer to the font and bitmap server managed bitmap.

 @leave KErrArgument The bitmap's handle is zero.

 @leave KErrAccessDenied The bitmap is in the ROM.

 @return A pointer to the newly constructed device.

 @panic EBitgdiPanicInvalidBitmap aFbsBitmap is NULL. */

 EXPORT_C CFbsBitmapDevice* CFbsBitmapDevice::NewL(CFbsBitmap* aFbsBitmap)

 	{

 	BG_ASSERT_ALWAYS(aFbsBitmap != NULL,EBitgdiPanicInvalidBitmap);

 	CFbsBitmapDevice* self = new(ELeave) CFbsBitmapDevice;

 	CleanupStack::PushL(self);

 	self->ConstructL(aFbsBitmap);

 	CleanupStack::Pop(); // self

 	return self;

 	}

 void CFbsBitmapDevice::ConstructL(CFbsBitmap* aFbsBitmap)

 	{

 	if(!aFbsBitmap->Handle())

 		User::Leave(KErrArgument);

 	if(aFbsBitmap->IsRomBitmap())

 		User::Leave(KErrAccessDenied);

 	iTypefaceStore = CFbsTypefaceStore::NewL(this);

 	iFbsBmp = new(ELeave) CFbsBitGcBitmap;

 	User::LeaveIfError(iFbsBmp->Duplicate(aFbsBitmap->Handle()));

 	const TDisplayMode dispMode = iFbsBmp->DisplayMode();

 	iDrawDevice = CFbsDrawDevice::NewBitmapDeviceL(iFbsBmp->SizeInPixels(), dispMode, iFbsBmp->DataStride());

 	TInt hwHandle = aFbsBitmap->HardwareBitmapHandle();

 	if(hwHandle)

 		{

 		TRAP_IGNORE(iGraphicsAccelerator = CHardwareGraphicsAccelerator::NewL(RHardwareBitmap(hwHandle)));

 		}

 	if (iGraphicsAccelerator==NULL)

 		{

 		TRAP_IGNORE(iGraphicsAccelerator = CSoftwareGraphicsAccelerator::NewL(iFbsBmp));

 		}

 	}

 /** Resizes the device.

 @param aSize The new size in pixels. 

 @return KErrNone, if successful; otherwise another of the system-wide error 

 codes. */

 EXPORT_C TInt CFbsBitmapDevice::Resize(const TSize& aSize)

 	{

 	if(!iDrawDevice || !iFbsBmp)

 		return(KErrGeneral);

 	if(aSize.iWidth < 0 || aSize.iHeight < 0)

 		return KErrArgument;

 	if (aSize.iWidth > KMaxPixelSize || aSize.iHeight > KMaxPixelSize)

 		return KErrTooBig;

     if (iFbsBmp->HardwareBitmapHandle())

         {

         return KErrNotSupported;

         }

 	const TDisplayMode dispMode = iFbsBmp->DisplayMode();

 	CFbsDrawDevice* drawDevice = NULL;

 	TRAPD(err, drawDevice = CFbsDrawDevice::NewBitmapDeviceL(aSize, dispMode, CFbsBitmap::ScanLineLength(aSize.iWidth, dispMode)));

 	if (err != KErrNone)

 		return err;

 	TInt ret = iFbsBmp->Resize(aSize);

 	if (ret != KErrNone)

 		{

 		delete drawDevice;

 		return ret;

 		}

 	delete iDrawDevice;

 	drawDevice->SetBits(NULL);

 	iDrawDevice = drawDevice;

 	iOrientation = CFbsBitGc::EGraphicsOrientationNormal;

 	// Now get a new GraphicsAccelerator but it doesn't matter if we fail, we can work without one

 	delete iGraphicsAccelerator;

 	iGraphicsAccelerator = NULL;

 	TRAP_IGNORE(iGraphicsAccelerator = CSoftwareGraphicsAccelerator::NewL(iFbsBmp));

 	return KErrNone;

 	}

 /**

 This method is called when you are about to start direct drawing to the bitmap memory.

 Calls to DrawingBegin() must be paired with a subsequent call to DrawingEnd().

 Also, code must not leave between a DrawingBegin() - DrawingEnd() pair.

 @param aAlways Not used.

 @see CFbsBitmapDevice::DrawingEnd()

 */

 EXPORT_C void CFbsBitmapDevice::DrawingBegin(TBool /*aAlways*/)

 	{

 	iFbsBmp->BeginDataAccess();

 	SetBits();

 	}

 /**

 This method is called when you have finished direct drawing to the bitmap memory.

 Calls to DrawingEnd() must correspond to a prior call to DrawingBegin().

 @param aAlways Not used.

 @see CFbsBitmapDevice::DrawingBegin()

 */

 EXPORT_C void CFbsBitmapDevice::DrawingEnd(TBool /*aAlways*/)

 	{

 	iDrawDevice->SetBits(NULL);

 	iFbsBmp->EndDataAccess(EFalse);

 	}

 void CFbsBitmapDevice::SetBits()

 	{

 #ifdef _DEBUG

 	// Bitmap devices only support normal orientation

 	TInt devHeight = iDrawDevice->SizeInPixels().iHeight;

 	MScalingSettings* scaling;

 	if (iDrawDevice->GetInterface(KScalingSettingsInterfaceID, (TAny*&)scaling) == KErrNone)

 		{

 		TInt factorX, factorY, divisorX, divisorY;

 		scaling->Get(factorX, factorY, divisorX, divisorY);

 		// Both divisorX and divisorY should be 1

 		if (factorY > 1)

 			{

 			devHeight = (devHeight - 1) * factorY + 1;

 			}

 		}

 #endif

 	BG_ASSERT_DEBUG(iFbsBmp->DataStride() == iDrawDevice->ScanLineBytes(), EBitgdiPanicInvalidBitmap);

 	BG_ASSERT_DEBUG(iFbsBmp->SizeInPixels().iHeight >= devHeight, EBitgdiPanicInvalidBitmap);

 	TUint32* data = iFbsBmp->DataAddress();

 	BG_ASSERT_ALWAYS(data, EBitgdiPanicInvalidBitmap);

 	iDrawDevice->SetBits(data);

 	}

 /** Copies a scanline into a buffer.

 The function provides a concrete implementation of the pure virtual

 function CBitmapDevice::GetScanLine(). */

 EXPORT_C void CFbsBitmapDevice::GetScanLine(TDes8& aBuf,

 											const TPoint& aPixel,

 											TInt aLength,

 											TDisplayMode aDispMode) const

  	{

 	iFbsBmp->BeginDataAccess();

 	CONST_CAST(CFbsBitmapDevice*,this)->SetBits();

 	CONST_CAST(CFbsBitmapDevice*,this)->DoGetScanLine(aBuf,aPixel,aLength,aDispMode);

 	iFbsBmp->EndDataAccess(ETrue);

 	}

 /** Gets the RGB colour of an individual pixel on a bitmapped graphics

 device.

 The function provides a concrete implementation of the pure virtual

 function CBitmapDevice::GetPixel(). */

 EXPORT_C void CFbsBitmapDevice::GetPixel(TRgb& aColor,const TPoint& aPoint) const

 	{

 	TRect deviceRect;

 	iDrawDevice->GetDrawRect(deviceRect);

 	if (!deviceRect.Contains(aPoint))

 		return;

 	iFbsBmp->BeginDataAccess();

 	((CFbsBitmapDevice*)this)->SetBits();

 	aColor = iDrawDevice->ReadPixel(aPoint.iX,aPoint.iY);

 	iFbsBmp->EndDataAccess(ETrue);

 	}

 /** Converts a horizontal dimension of a device in pixels to a horizontal

 dimension in twips.

 The function provides a concrete implementation of the pure virtual

 function MGraphicsDeviceMap::HorizontalPixelsToTwips(). */	 

 EXPORT_C TInt CFbsBitmapDevice::HorizontalPixelsToTwips(TInt aPixels) const

     {

 	return iFbsBmp->HorizontalPixelsToTwips(aPixels);

 	}

 /** Converts a vertical dimension of a device in pixels to a vertical

 dimension in twips.

 The function provides a concrete implementation of the pure virtual

 function MGraphicsDeviceMap::VerticalPixelsToTwips(). */

 EXPORT_C TInt CFbsBitmapDevice::VerticalPixelsToTwips(TInt aPixels) const

   	{

 	return iFbsBmp->VerticalPixelsToTwips(aPixels);

 	}

 /** Gets the size of the device, in twips.

 @return The size of the device. */

 EXPORT_C TSize CFbsBitmapDevice::SizeInTwips() const

 	{

 	return iFbsBmp->SizeInTwips();

 	}

 /**  Converts a horizontal dimension of a device in twips to a horizontal

 dimension in pixels.

 The function provides a concrete implementation of the pure virtual

 function MGraphicsDeviceMap::HorizontalTwipsToPixels(). */

 EXPORT_C TInt CFbsBitmapDevice::HorizontalTwipsToPixels(TInt aTwips) const

 	{

 	return iFbsBmp->HorizontalTwipsToPixels(aTwips);

 	}

 /** Converts a vertical dimension of a device in twips to a vertical

 dimension in pixels.

 The function provides a concrete implementation of the pure virtual

 function MGraphicsDeviceMap::VerticalTwipsToPixels(). */	

 EXPORT_C TInt CFbsBitmapDevice::VerticalTwipsToPixels(TInt aTwips) const

     {

 	return iFbsBmp->VerticalTwipsToPixels(aTwips);

 	}

 /** Gets the palette attributes of the device.

 The function provides a concrete implementation of the pure virtual

 function CGraphicsDevice::PaletteAttributes(). */	

 EXPORT_C void CFbsBitmapDevice::PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const

     {

 	aModifiable = (iDrawDevice->DisplayMode() == EColor256);

 	aNumEntries = TDisplayModeUtils::NumDisplayModeColors(iDrawDevice->DisplayMode());

 	}

 /** Sets the device's palette to the specified palette.

 Setting the palette is only possible if the device has a modifiable palette, 

 which can be determined by calling PaletteAttributes().

 The function provides a concrete implementation of the pure virtual

 function CGraphicsDevice::SetPalette(). */

 EXPORT_C void CFbsBitmapDevice::SetPalette(CPalette* aPalette)

 	{

 	SetCustomPalette(aPalette); // Have to ignore error for compatibility

 	}

 /** Gets the device's current palette.

 This function is only supported if the device has a modifiable palette, 

 which can be determined by calling PaletteAttributes().

 The function provides a concrete implementation of the pure virtual

 function CGraphicsDevice::GetPalette(). */	

 EXPORT_C TInt CFbsBitmapDevice::GetPalette(CPalette*& aPalette) const

     {

 	return iDrawDevice->GetCustomPalette(aPalette);

 	}

 /**

 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 CFbsBitmapDevice object in a consistent state - 

 scaling settings will be set with their default values (the scaling is switched off),

 the device's dither origin will be set to (0,0), scaling origin to (0,0).

 Note: If the device was scaled or its dither origin was set with a non-default value,

 it has to be rescaled again, respectivelly the dither origin has to be set again.

 Note: All graphics contexts, already created by the device, should be 

 re-activated calling CFbsBitGc::Activate(). 

 Note: Do not call SwapWidthAndHeight() between DrawingBegin() and DrawingEnd() calls!

 @return KErrNone The call was successfull.

 @return KErrAccessDenied ROM bitmap size can't be swapped.

 @return KErrNotSupported Hardware bitmap size can't be swapped.

 @return KErrGeneral iDrawDevice or iFbsBmp is NULL.

 */

 EXPORT_C TInt CFbsBitmapDevice::SwapWidthAndHeight()

 	{

 	if(!iDrawDevice || !iFbsBmp)

 		{

 		return KErrGeneral;

 		}

 	TInt err = iFbsBmp->SwapWidthAndHeight();

 	if(err == KErrNone)

 		{

 		iDrawDevice->SwapWidthAndHeight();

 		}

 	return err;

 	}

 /**

  Required to ensure BC between NGage and 7.0S platforms.  

  Functions are exported at ordinal corresponding to where NGage platform

  has extended this library and must not be moved.

  */

 EXPORT_C void DummyReserved1()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved2()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved3()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved4()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved5()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved6()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved7()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved8()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved9()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}

 EXPORT_C void DummyReserved10()

 	{

 	User::Panic(_L("Dummy Function"), 0);

 	}