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