--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/bitgdi/sbit/BITMAPDV.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,392 @@
+// 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);
+	}