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