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

 #include <bitdev.h>

 #include <bitdraw.h>

 #include <bitdrawscaling.h>

 #include <bitdraworigin.h>

 #include <bitdrawinterfaceid.h>

 #include "BITPANIC.H"

 /**

 Used by RectCompare()

 @internalComponent

 */

 enum {EScanBufSize=0x80}; 

 CFbsDevice::CFbsDevice():

 	CBitmapDevice()

 	{

 	iFbs = RFbsSession::GetSession();

 	}

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

 EXPORT_C CFbsDevice::~CFbsDevice()

 	{

 	delete iDrawDevice;

 	delete iTypefaceStore;

 	delete iBitBltMaskedBuffer;

 	delete iGraphicsAccelerator;

 	}

 /** Creates a font and bitmap server graphics context for the device and 

 activates it.

 It is the responsibility of the caller to delete the graphics context when 

 it is no longer needed.

 @param aGc On return, contains a pointer to the graphics context. 

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

 codes. */

 EXPORT_C TInt CFbsDevice::CreateContext(CFbsBitGc*& aGc)

 	{

 	TRAPD(ret,aGc = CFbsBitGc::NewL());

 	if (ret != KErrNone)

 		return ret;

 	if (iScreenDevice)

 		aGc->ActivateNoJustAutoUpdate(this);

 	else

 		aGc->Activate(this);

 	return KErrNone;

 	}

 /** Gets the device's display mode.

 @return The display mode of the device. */

 EXPORT_C TDisplayMode CFbsDevice::DisplayMode() const

 	{

 	return iDrawDevice->DisplayMode();

 	}

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

 @return The width and height of the device, in pixels */

 EXPORT_C TSize CFbsDevice::SizeInPixels() const

 	{

 	return iDrawDevice->SizeInPixels();

 	}

 /** Compares two rectangles, including their contents.

 This function is intended for use by test code only.

 @param aSourceRect The first rectangle to be compared (in this device).

 @param aDevice The font and bitmap server device in which the second rectangle 

 is found.

 @param aDeviceRect The second rectangle to be compared.

 @return ETrue if the rectangles are the same; EFalse otherwise. */

 EXPORT_C TBool CFbsDevice::RectCompare(const TRect& aSourceRect,

 									   const CFbsDevice& aDevice,

 									   const TRect& aDeviceRect) const

 	{

 	TRect deviceRect1;

 	iDrawDevice->GetDrawRect(deviceRect1);

 	TRect deviceRect2;

 	aDevice.iDrawDevice->GetDrawRect(deviceRect2);

 	TRect area(deviceRect1);

 	TRect devarea(deviceRect2);

 	TRect tmp(aSourceRect);

 	TRect tmp2(aDeviceRect);

 	tmp.Intersection(area);

 	tmp2.Intersection(devarea);

 	if (tmp!=aSourceRect ||

 		tmp2!=aDeviceRect)

 		return(EFalse);

 	TInt width=aSourceRect.Width();

 	TInt height=aSourceRect.Height();

 	if (width!=aDeviceRect.Width() ||

 		height!=aDeviceRect.Height())

 		return(EFalse);

 	TBuf8<EScanBufSize> buf1;

 	TBuf8<EScanBufSize> buf2;

 	TDisplayMode displayMode = iDrawDevice->ScanLineDisplayMode();

 	if (displayMode < EGray256)

 		displayMode = EGray256;

 	else if (displayMode == EColor16)

 		displayMode = EColor256; // Increase the display mode so that each pixel takes at least one byte

 	TInt colsPerBuf=(EScanBufSize*EScanBufSize)/

 				CFbsBitmap::ScanLineLength(EScanBufSize, displayMode);

 	TBool ret=EFalse;

 	for(TInt row=0;row<height;row++)

 		{

 		TInt read=0;

 		TInt len=colsPerBuf;

 		do

 			{

 			if ((width-read)<len)

 				len=width-read;

 			GetScanLine(buf1,TPoint(aSourceRect.iTl.iX+read,aSourceRect.iTl.iY+row),len,displayMode);

 			aDevice.GetScanLine(buf2,TPoint(aDeviceRect.iTl.iX+read,aDeviceRect.iTl.iY+row),len,displayMode);

 			if (buf1!=buf2)

 				goto failed;

 			read+=len;

 			} while(read<width);

 		}

 	ret=ETrue;

 failed:

 	return(ret);

 	}

 /** Adds a font file to the device's typeface store. The specified font

 file must be accessible to any process, i.e. not located inside an

 application's private directory.

 @param aName The name of the font file. 

 @param aId On return, the UID value of the font file.

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

 codes. */

 EXPORT_C TInt CFbsDevice::AddFile(const TDesC& aName,TInt& aId)

 	{

 	return iTypefaceStore->AddFile(aName,aId);

 	}

 /** Decrements the reference count of a file which was added using 

 AddFile(), and removes the file from the typeface store if the reference count reaches zero. 

 If zero is passed as parameter, then an attempt is made to remove all font objects

 from the device's typeface store provided none of the fonts in the store are 

 currently accessed, otherwise it has no effect.

 @param aId The UID value of the font file to be removed. The default is 0. */

 EXPORT_C void CFbsDevice::RemoveFile(TInt aId)

 	{

 	iTypefaceStore->RemoveFile(aId);

 	}

 /** Provides access to a client-side font object in the device's typeface store that most closely 

 matches a font specification.

 When the font is no longer needed, call @c ReleaseFont().

 Note that this deprecated function is replaced by the new @c GetNearestFontToDesignHeightInTwips() 

 yielding (virtually) the same result. However clients are strongly encouraged to use the new

 @c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 

 character within any given text string will fit within the given amount of twips, whereas the design 

 height is an aesthetic unit decided by the font designer without strict physical meaning, which 

 may result in cropped characters.

 @param aFont On return, points to the font which most closely matches the 

 specified font.

 @param aFontSpec An absolute font specification. Its iHeight member is 

 interpreted as being in twips.

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

 codes.

 @deprecated */

 EXPORT_C TInt CFbsDevice::GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec)

 	{

 	return GetNearestFontToDesignHeightInTwips(aFont, aFontSpec);

 	}

 /** Creates a client-side font from those available in the device's typeface 

 store that most closely matches a font specification.

 When the font is no longer needed, call @c ReleaseFont().

 Note that this deprecated function is replaced by the new @c GetNearestFontToDesignHeightInPixels() 

 yielding (virtually) the same result. However clients are strongly encouraged to use the new

 @c GetNearestFontToMaxHeightInPixels() function instead. This will guarantee that every 

 character within any given text string will fit within the given amount of pixels, whereas the design 

 height is an aesthetic unit decided by the font designer without strict physical meaning, which 

 may result in cropped characters.

 @param aFont On return, points to the font which most closely matches the 

 specified font.

 @param aFontSpec An absolute font specification. Its iHeight member is 

 interpreted as being in pixels.

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

 codes.

 @deprecated */

 EXPORT_C TInt CFbsDevice::GetNearestFontInPixels(CFont*& aFont, const TFontSpec& aFontSpec)

 	{

 	return GetNearestFontToDesignHeightInPixels(aFont, aFontSpec);

 	}

 /** Creates a client-side font from those available in the device's typeface 

 store that most closely matches a font specification. 

 When the font is no longer needed, call @c ReleaseFont().

 This new function replaces the deprecated @c GetNearestFontInTwips() yielding (virtually) the 

 same result. However clients are strongly encouraged to use the new

 @c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 

 character within any given text string will fit within the given amount of twips, whereas the design 

 height is an aesthetic unit decided by the font designer without strict physical meaning, which 

 may result in cropped characters.

 @param aFont On return, points to the font which most closely matches the 

 specified font.

 @param aFontSpec An absolute font specification. Its iHeight member is 

 interpreted as being in twips.

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

 codes. */

 EXPORT_C TInt  CFbsDevice::GetNearestFontToDesignHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec)

 	{

 	return iTypefaceStore->GetNearestFontToDesignHeightInTwips(aFont, aFontSpec);

 	}

 /** Creates a client-side font from those available in the device's typeface 

 store that most closely matches a font specification. 

 When the font is no longer needed, call @c ReleaseFont().

 This new function replaces the deprecated @c GetNearestFontInPixels() yielding (virtually) the 

 same result. However clients are strongly encouraged to use the new

 @c GetNearestFontToMaxHeightInPixels() function instead. This will guarantee that every 

 character within any given text string will fit within the given amount of pixels, whereas the design 

 height is an aesthetic unit decided by the font designer without strict physical meaning, which 

 may result in cropped characters.

 @param aFont On return, points to the font which most closely matches the 

 specified font.

 @param aFontSpec An absolute font specification. Its iHeight member is 

 interpreted as being in pixels.

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

 codes. */

 EXPORT_C TInt  CFbsDevice::GetNearestFontToDesignHeightInPixels(CFont*& aFont, const TFontSpec& aFontSpec)

 	{

 	return iTypefaceStore->GetNearestFontToDesignHeightInPixels(aFont, aFontSpec);

 	}

 /** Creates a client-side font from those available in the device's typeface 

 store that most closely matches a font specification. 

 When the font is no longer needed, call @c ReleaseFont().

 The font and bitmap server returns a pointer to the nearest matching font 

 from those available. Matches to max height of font - this does its best 

 to return a font that will fit within the maximum height specified (but 

 note that variations due to hinting algorithms may rarely result in this 

 height being exceeded by up to one pixel). Problems can also be 

 encountered with bitmap fonts where the typeface exists but doesn't have 

 a font small enough.

 @param aFont On return, the pointer is set to point to the device font which 

 most closely approximates to the required font specification.

 @param aFontSpec An absolute font specification. 

 @param aMaxHeight The maximum height in twips within which the font must

 fit - this overrides the height specified in aFontSpec. If maximum height

 is greater than 1024 pixels, the function returns KErrTooBig. And returns KErrArgument

 if equals to 1 pixel.

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

 codes. */

 EXPORT_C TInt  CFbsDevice::GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight)

 	{

 	return iTypefaceStore->GetNearestFontToMaxHeightInTwips(aFont, aFontSpec, aMaxHeight);

 	}

 /** Creates a client-side font from those available in the device's typeface 

 store that most closely matches a font specification. 

 When the font is no longer needed, call @c ReleaseFont().

 The font and bitmap server returns a pointer to the nearest matching font 

 from those available. Matches to max height of font - this does its best 

 to return a font that will fit within the maximum height specified (but 

 note that variations due to hinting algorithms may rarely result in this 

 height being exceeded by up to one pixel). Problems can also be 

 encountered with bitmap fonts where the typeface exists but doesn't have 

 a font small enough.

 @param aFont On return, the pointer is set to point to the device font which 

 most closely approximates to the required font specification.

 @param aFontSpec An absolute font specification. 

 @param aMaxHeight The maximum height in pixels within which the font must

 fit - this overrides the height specified in aFontSpec.  If maximum height

 is greater than 1024 pixels, the function returns KErrTooBig. And returns KErrArgument

 if equals to 1 pixel.

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

 codes. */

 EXPORT_C TInt  CFbsDevice::GetNearestFontToMaxHeightInPixels(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight)

 	{

 	return iTypefaceStore->GetNearestFontToMaxHeightInPixels(aFont, aFontSpec, aMaxHeight );

 	}

 /** Gets a specific bitmap font, identified by its UID, from the device's typeface 

 store.

 When the font is no longer needed, call ReleaseFont().

 @param aFont On return, set to point to the font.

 @param aUId The UID identifying the bitmap font.

 @param aStyle Algorithmic style for the font.

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

 codes. */

 EXPORT_C TInt CFbsDevice::GetFontById(CFont*& aFont,TUid aUId,const TAlgStyle& aStyle)

 	{

 	return iTypefaceStore->GetFontById(aFont,aUId,aStyle);

 	}

 /** Marks the specified font as no longer needed by the user of the device.

 As fonts can be shared between applications, this function does not delete 

 the copy of the font from RAM unless the font is only being used by this device.

 @param aFont A pointer to the font to be released. */

 EXPORT_C void CFbsDevice::ReleaseFont(CFont* aFont)

 	{

 	iTypefaceStore->ReleaseFont(aFont);

 	}

 /** Gets the number of typefaces supported by the device.

 @return The number of typefaces supported. */

 EXPORT_C TInt CFbsDevice::NumTypefaces() const

 	{

 	return iTypefaceStore->NumTypefaces();

 	}

 /** Gets information about an indexed typeface.

 @param aTypefaceSupport Provides information about the typeface, including 

 its name and attributes.

 @param aTypefaceIndex The index of the requested typeface in the device's 

 typeface store; between zero and NumTypefaces() 1 inclusive.

 @see CGraphicsDevice::TypefaceSupport() */

 EXPORT_C void CFbsDevice::TypefaceSupport(TTypefaceSupport& aTypefaceSupport,

 										  TInt aTypefaceIndex) const

 	{

 	iTypefaceStore->TypefaceSupport(aTypefaceSupport,aTypefaceIndex);

 	}

 /** Gets the height of a font in twips.

 This is an implementation of

 CGraphicsDevice::FontHeightInTwips(). */

 EXPORT_C TInt CFbsDevice::FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const

     {

 	return iTypefaceStore->FontHeightInTwips(aTypefaceIndex,aHeightIndex);

 	}

 /**  Gets the height, in pixels, of the specified typeface at one of its

 defined heights.

 This is an implementation of

 CBitMapDevice::FontHeightInPixels(). */

 EXPORT_C TInt CFbsDevice::FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const

 	{

 	return iTypefaceStore->FontHeightInPixels(aTypefaceIndex,aHeightIndex);

 	}

 	/**

 	Function to add a CLinkedTypefaceSpecification to the font and bitmap server typeface store.

 	@capability ECapabilityWriteDeviceData

 	@publishedPartner

 	@released

 	@param aLinkedTypefaceSpec.  The typeface specification to be added.

 	@param aId. A unique ID for the typeface

 	@return an global error code

 	@see CLinkedTypefaceSpecification

 	*/

 	EXPORT_C TInt CFbsDevice::RegisterLinkedTypeface(const CLinkedTypefaceSpecification& aLinkedTypefaceSpec, TInt& aId)

 	{

 	return iTypefaceStore->RegisterLinkedTypeface(aLinkedTypefaceSpec, aId);

 	}

 /** Sets the variable 8 bits per pixel colour palette, replacing the system default 

 one. Only the entries in the system default palette which have corresponding 

 entries in aPalette are overwritten, i.e. if aPalette contains fewer than 

 256 colours, some will remain unchanged. If aPalette has more than 256 entries, 

 the additional entries are ignored.

 @param aPalette The custom palette.

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

 codes. */

 EXPORT_C TInt CFbsDevice::SetCustomPalette(const CPalette* aPalette)

 	{

 	TInt ret = iDrawDevice->SetCustomPalette(aPalette);

 	if(ret==KErrNone)

 		{

 		// Graphics accelerator doesn't currently support changing palettes,

 		// so delete it if the palette is successfully changed.

 		delete iGraphicsAccelerator;

 		iGraphicsAccelerator = NULL;

 		}

 	return ret;

 	}

 /**

 The method gets a scanline and puts the scanline data into aBuf.

 @internalComponent

 @param aBuf The destination buffer. It should be with enough length to collect 

 requested scanline data.

 @param aPixel The first pixel of the requested scanline data

 @param aLength The length in pixels of requested data

 @param aDispMode requested scanline should be converted regarding aDispMode parameter

 */

 void CFbsDevice::DoGetScanLine(TDes8& aBuf,const TPoint& aPixel,TInt aLength,

 							   TDisplayMode aDispMode)

 	{

 	TRect deviceRect;

 	iDrawDevice->GetDrawRect(deviceRect);

 	if (aPixel.iY < deviceRect.iTl.iY || aPixel.iY > deviceRect.iBr.iY)

 		return;

 	TInt byteLength = 0;

 	TInt bitsPerPixel = 0;

 	switch(aDispMode)

 		{

 	case EGray2:

 		bitsPerPixel = 1;

 		byteLength = aLength / 8 + (aLength % 8 ? 1 : 0);

 		break;

 	case EGray4:

 		bitsPerPixel = 2;

 		byteLength = aLength / 4 + (aLength % 4 ? 1 : 0);

 		break;

 	case EGray16:

 	case EColor16:

 		bitsPerPixel = 4;

 		byteLength = aLength / 2 + (aLength % 2 ? 1 : 0);

 		break;

 	case EGray256:

 	case EColor256:

 		bitsPerPixel = 8;

 		byteLength = aLength;

 		break;

 	case EColor4K:

 	case EColor64K:

 		bitsPerPixel = 16;

 		byteLength = aLength * 2;

 		break;

 	case EColor16M:

 		bitsPerPixel = 24;

 		byteLength = aLength * 3;

 		break;

 	case ERgb:

 	case EColor16MU:

 	case EColor16MA:

 	case EColor16MAP:

 		bitsPerPixel = 32;

 		byteLength = aLength * 4;

 		break;

 	case ENone:

 	default:

 		BG_PANIC_ALWAYS(EBitgdiPanicInvalidDisplayMode);

 		}

 	if (byteLength > aBuf.MaxLength())

 		{

 		TInt pixelsMaxCount = (aBuf.MaxLength() * 8) / bitsPerPixel;

 		if(aLength > pixelsMaxCount)

 			{

 			aLength = pixelsMaxCount;

 			}

 		aBuf.SetMax();

 		}

 	else

 		{

 		aBuf.SetLength(byteLength);

 		}

 	TInt x1 = Max(aPixel.iX, deviceRect.iTl.iX);

 	TInt x2 = Min(aPixel.iX + aLength, deviceRect.iBr.iX);

 	if (x2 <= x1)

 		return;

 	TUint8* vals = (TUint8*)(aBuf.Ptr());

 	iDrawDevice->ReadLine(x1,aPixel.iY,x2 - x1,vals,aDispMode);

 	}

 void CFbsDevice::TruncateRect(TRect& aRect)

 	{

 	TInt width = iDrawDevice->SizeInPixels().iWidth << 4;

 	TInt height = iDrawDevice->SizeInPixels().iHeight << 4;

 	aRect.iTl.iX = Min(aRect.iTl.iX,width);

 	aRect.iTl.iY = Min(aRect.iTl.iY,height);

 	aRect.iBr.iX = Min(aRect.iBr.iX,width);

 	aRect.iBr.iY = Min(aRect.iBr.iY,height);

 	width =- width;

 	height =- height;

 	aRect.iTl.iX = Max(aRect.iTl.iX,width);

 	aRect.iTl.iY = Max(aRect.iTl.iY,height);

 	aRect.iBr.iX = Max(aRect.iBr.iX,width);

 	aRect.iBr.iY = Max(aRect.iBr.iY,height);

 	}

 TBool CFbsDevice::SetOrientation(CFbsBitGc::TGraphicsOrientation aOrientation)

 	{

 	TBool ret = iDrawDevice->SetOrientation((CFbsDrawDevice::TOrientation)aOrientation);

 	if(ret)

 		iOrientation = aOrientation;

 	return ret;

 	}

 /**

 Depending on the current graphics hardware this 

 will return one of the 16M video modes defined in

 TDisplayMode, or ENone if a 16M video mode is not supported.

 @see TDisplayMode

 @return	a 16M display mode or ENone.

 */

 EXPORT_C TDisplayMode CFbsDevice::DisplayMode16M()

 	{

 	return CFbsDrawDevice::DisplayMode16M();

 	}

 /**

 Sets scaling factor by which the drawing device should scale the drawing images.

 If you want to un-scale the device, call SetScalingFactor() with Origin (0,0), 

 factorX = 1, factorY = 1, divisorX = 1, divisorY = 1.

 Note: The existing graphics acceleration interface does not have support for scaling.

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

 re-activated calling CFbsBitGc::Activate().

 @param aOrigin Specifies physical coordinates of the new scaling origin

 of the drawing device. The drawing device maps the logical point [0, 0] to

 the "aOrigin" physical point .

 @param aFactorX Scaling factor for the X-axis of the screen device.

 @param aFactorY Scaling factor for the y-axis of the screen device.

 @param aDivisorX Not used. Should be set to 1.

 @param aDivisorY Not used. Should be set to 1.

 @return KErrNone If the method succeeds.

         KErrNotSupported The drawing device does not have scaling capabilities.

 */

 EXPORT_C TInt CFbsDevice::SetScalingFactor(const TPoint& aOrigin,

 										   TInt aFactorX, TInt aFactorY,

 										   TInt aDivisorX, TInt aDivisorY)

 	{

 	//This class takes care about setting scaling and origin and restoring the original values

 	//if some of the operations fails.

 	class TInitializer

 		{

 	public:

 		TInitializer(CFbsDrawDevice* aDrawDevice) :

 			iScalingSettings(NULL), iOriginInterface(NULL),

 			iError(KErrNone),

 			iFx(1), iFy(1), iDivX(1), iDivY(1),

 			iOrigin(0, 0)

 			{//Acquire the interfaces and save the original settings.  They will be used if the initialization fails.

 			iError = aDrawDevice->GetInterface(KScalingSettingsInterfaceID, 

 											   reinterpret_cast <TAny*&> (iScalingSettings));

 			if(iError == KErrNone)

 				{

 				BG_ASSERT_DEBUG_INVARIANT(iScalingSettings);

 				iScalingSettings->Get(iFx, iFy, iDivX, iDivY);

 				iError = aDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 

 												   reinterpret_cast <TAny*&> (iOriginInterface));

 				if(iError == KErrNone)

 					{

 					BG_ASSERT_DEBUG_INVARIANT(iOriginInterface);

 					iOriginInterface->Get(iOrigin);

 					}

 				}

 			}

 		~TInitializer()

 			{//Restore the original settings if setting of the new ones had failed.

 			if(iError != KErrNone)

 				{

 				if(iScalingSettings)

 					{

 					(void)iScalingSettings->Set(iFx, iFy, iDivX, iDivY);

 					}

 				if(iOriginInterface)

 					{

 					(void)iOriginInterface->Set(iOrigin);

 					}

 				}

 			}

 		void SetScalingFactor(TInt aFactorX, TInt aFactorY, TInt aDivisorX, TInt aDivisorY)

 			{

 			if(iError == KErrNone)

 				{

 				iError = iScalingSettings->Set(aFactorX, aFactorY, aDivisorX, aDivisorY);

 				}

 			}

 		void SetOrigin(const TPoint& aOrigin)

 			{

 			if(iError == KErrNone)

 				{

 				iError = iOriginInterface->Set(aOrigin);

 				}

 			}

 		TInt Error() const

 			{

 			return iError;

 			}

 	private:

 		MScalingSettings* iScalingSettings;

 		MDrawDeviceOrigin* iOriginInterface;

 		TInt iError;

 		TInt iFx, iFy, iDivX, iDivY;

 		TPoint iOrigin;

 		};

 	TInitializer initializer(iDrawDevice);

 	initializer.SetScalingFactor(aFactorX, aFactorY, aDivisorX, aDivisorY);

 	initializer.SetOrigin(aOrigin);

 	TInt err = initializer.Error();

 	if(err == KErrNone && 

 	  (aFactorX != aDivisorX || aFactorY != aDivisorY || aOrigin.iX != 0 || aOrigin.iY != 0))

 		{

 		//Graphics accelerator interface doesn't have support for scaling&origin.

 		delete iGraphicsAccelerator;

 		iGraphicsAccelerator = NULL;

 		}

 	return err;

 	}

 /**

 Gets logical coordinates of the drawing rectangle.

 If the device is not scaled, logocal coordinates of the drawing rectangle are the

 same as its physical coordinates.

 @param aRect Upon return aRect contains drawing rectangle logical coordinates.

 */

 EXPORT_C void CFbsDevice::GetDrawRect(TRect& aRect) const

 	{

 	iDrawDevice->GetDrawRect(aRect);

 	}

 /**

 An overloaded version of DrawingBegin(TBool). Similarly to that method, calls to

 DrawingBegin(const CFbsBitmap*, TBool) must be paired with a subsequent call to

 DrawingEnd(const CFbsBitmap*, TBool). Also, code must not leave between a

 DrawingBegin(const CFbsBitmap*, TBool) - DrawingEnd(const CFbsBitmap*, TBool) pair.

 @param aBitmap An additional parameter compared to the basic overload.

 aBitmap is a pointer to a CFbsBitmap object to be frozen. If a null pointer

 is given then the method panics.

 @param aAlways Not used.

 @see CFbsBitmapDevice::DrawingBegin()

 */

 void CFbsDevice::DrawingBegin(const CFbsBitmap* aBitmap, TBool /*aAlways*/)

 	{

 	BG_ASSERT_DEBUG(aBitmap, EBitgdiPanicInvalidBitmap);

 	if (aBitmap)

 		aBitmap->BeginDataAccess();

 	DrawingBegin();

 	}

 /**

 This must always be called after DrawingBegin(const CFbsBitmap*, TBool).

 Like DrawingBegin(const CFbsBitmap*, TBool) it will panic in debug builds

 if passed a null pointer.

 @param aBitmap A pointer to a CFbsBitmap object to be unfrozen.

 @param aAlways Not used.

 @see CFbsBitmapDevice::DrawingEnd()

 */

 void CFbsDevice::DrawingEnd(const CFbsBitmap* aBitmap, TBool /*aAlways*/)

 	{

 	BG_ASSERT_DEBUG(aBitmap, EBitgdiPanicInvalidBitmap);

 	if (aBitmap)

 		aBitmap->EndDataAccess(ETrue);

 	DrawingEnd();

 	}

 /**

 Used to set an offset

 @param aOrigin The offset to give

 @return KErrNone on success, otherwise a system wide error code

 */

 EXPORT_C TInt CFbsDevice::SetDrawDeviceOffset(const TPoint& aOrigin)

 	{

 	if(!iDrawDevice)

 		{

 		return KErrGeneral;

 		}

 	MDrawDeviceOrigin* drawDevice=NULL;

 	if (	iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID,reinterpret_cast<void*&>(drawDevice))<KErrNone

 		||	drawDevice==NULL

 			)

 		{

 		return KErrNotSupported;

 		}

 	drawDevice->Set(aOrigin);

 	return KErrNone;

 	}