diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/sbit/FBSERVDV.CPP --- /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 +#include +#include +#include +#include +#include +#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 buf1; + TBuf8 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;rowAddFile(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 (iScalingSettings)); + if(iError == KErrNone) + { + BG_ASSERT_DEBUG_INVARIANT(iScalingSettings); + iScalingSettings->Get(iFx, iFy, iDivX, iDivY); + iError = aDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, + reinterpret_cast (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(drawDevice))Set(aOrigin); + return KErrNone; + }