diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdiadaptation/hwsrc/directgdidriverimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/directgdiadaptation/hwsrc/directgdidriverimpl.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,920 @@ +// Copyright (c) 2007-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 "directgdidriverimpl.h" +#include "directgdiimagetargetimpl.h" +#include "directgdiimagesourceimpl.h" +#include "directgdiadapter.h" +#include "directgdiimageref.h" +#include "vgengine.h" +#include "confighelper.h" +#include +#include +#include +#include + +#ifndef __WINS__ +// Static member variable +XDirectGdiDriverProcessState CDirectGdiDriverImpl::gProcessState; +#endif + +/** +Handles an EGL failure. It may either set the passed-in TInt to a Symbian OS-mapped error code, +or panic the specified panic code, depending on the egl failure. Done as a macro so the line number is reported. +*/ +#define HANDLE_EGL_ERROR(err, panic) \ + { \ + const EGLint eglError = eglGetError(); \ + if (eglError == EGL_BAD_ALLOC) \ + err = KErrNoMemory; \ + else if (eglError == EGL_CONTEXT_LOST) \ + err = KErrDied; \ + else if (eglError != EGL_SUCCESS) \ + { \ + TBuf16<256> _message; \ + _message.Format(_L16("EGL Error: %x\n"), eglError); \ + GRAPHICS_LOGD_DEBUG(_message); \ + GRAPHICS_ASSERT_DEBUG(eglError == EGL_SUCCESS, panic); \ + } \ + } + +/** +Populates the config hash map with matching EGL configs, based on the supported pixel types. + +@param aDisplay A valid EGL display to retrieve EGL configs for. + +@panic DGDIAdapter 24, if no suitable EGL configs are present (debug-only). +@panic DGDIAdapter 25, if no exact matching EGL config can be found. +@panic DGDIAdapter 29, if RSgImage::GetPixelFormats returns pixel count <= 0. + +@pre EGL has been initialised by eglInitialize(). +@post The supported EGL configs are stored in the hash map. + +@return KErrNoError if successful, KErrNotReady if EGL was not initialised, otherwise one of the +system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::InitializeEglConfigs(EGLDisplay aDisplay) + { +#ifdef _DEBUG_DIRECTGDI + GRAPHICS_LOG_DEBUG("InitializeEglConfigs"); +#endif + TInt err = KErrNone; + + // Get EGL configs upfront and store them in a hash map + EGLint configSize = 0; + EGLConfig *configs = NULL; + + // Query RsgImage for the number of supported target pixel formats. Then we know how much memory should be + // allocated to the pixelformats array. + TInt count = 0; + TSgImageInfo imageInfo; + imageInfo.iUsage = ESgUsageDirectGdiTarget; + imageInfo.iSizeInPixels = TSize(1,1); + TUidPixelFormat* pixelFormats = NULL; + err = RSgImage::GetPixelFormats(imageInfo, NULL, count); + GRAPHICS_ASSERT_DEBUG(count > 0, EDirectGdiPanicNoValidPixelFormats); + + if (err == KErrNone) + { + pixelFormats = new TUidPixelFormat[count]; + if (pixelFormats == NULL) + { + err = KErrNoMemory; + } + } + + if (err == KErrNone) + { + err = RSgImage::GetPixelFormats(imageInfo, pixelFormats, count); + if (!eglGetConfigs(aDisplay, configs, 0, &configSize) && configSize) + { + HANDLE_EGL_ERROR(err, EDirectGdiPanicNoAvailableConfigs); + } + } + + if (err == KErrNone) + { + configs = new EGLConfig[configSize]; + if (configs == NULL) + { + err = KErrNoMemory; + } + } + + for (TInt i = 0; (i < count) && (err == KErrNone); ++i) + { + // Finds a suitable config to map to this bitmap. + TInt selPixmapAttribs = TConfigHelper::MatchPixelType(pixelFormats[i]); + EGLint numConfigs = 0; + if (!eglChooseConfig(aDisplay, TConfigHelper::KSurfaceAttribs[selPixmapAttribs], configs, configSize, &numConfigs)) + { + HANDLE_EGL_ERROR(err, EDirectGdiPanicNoMatchingConfig); + break; + } + GRAPHICS_ASSERT_ALWAYS(numConfigs >= 1, EDirectGdiPanicNoAvailableConfigs); + // Find an exact matching config from the available configs. + TInt match = TConfigHelper::GetSuitablePixmapConfigIndex(aDisplay, configs, numConfigs, selPixmapAttribs); + GRAPHICS_ASSERT_ALWAYS(match >= 0, EDirectGdiPanicNoMatchingConfig); + EGLConfig currentConfig = configs[match]; + + // Store this matching config and the pixel type in the hash map. + err = iPixelConfigMap.Insert(selPixmapAttribs, currentConfig); + } + + delete [] configs; + delete [] pixelFormats; + + return err; + } + +/** +Constructor to allocate memory to CDirectGdiDriverImpl object. + +@param aInternal On success, will store a pointer to the newly created CDirectGdiDriverImpl. +@param aLibrary +@return KErrNone if successful, otherwise one of the system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::New(CDirectGdiDriverInternal*& aInternal, RLibrary aLibrary) + { + CDirectGdiDriverImpl* self = new CDirectGdiDriverImpl(aLibrary); + if(!self) + return KErrNoMemory; + TInt err = self->Construct(); + if(err != KErrNone) + { + aInternal = NULL; + delete self; + return err; + } + aInternal = self; + return err; + } + +/** +Destructor - frees the memory for the hashmaps and the source and target arrays. + +@panic DGDIAdapter 45, if images are still in the source or target image array (debug-only). +*/ +CDirectGdiDriverImpl::~CDirectGdiDriverImpl() + { + // Check that there are no drawbles left in the drawable array + GRAPHICS_ASSERT_DEBUG(iSourceArray.Count() == 0, EDirectGdiPanicItemsLeftInImageArray); + GRAPHICS_ASSERT_DEBUG(iTargetArray.Count() == 0, EDirectGdiPanicItemsLeftInImageArray); + + iSourceArray.Close(); + iTargetArray.Close(); + + delete iVgImageCache; + + THashMapIter contextIter(iPixelContextMap); + const EGLContext* context = contextIter.NextValue(); + while (context) + { + eglDestroyContext(iDisplay, *context); + context = contextIter.NextValue(); + } + iPixelContextMap.Close(); + iPixelConfigMap.Close(); + delete iGlyphImageStorage; + + eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + // This will terminate the display if it is the last driver. + ProcessState().CloseDriver(iDisplay); + eglReleaseThread(); + + SgDriver::Close(); + } + +/** +@see CDirectGdiDriver::Flush() +*/ +void CDirectGdiDriverImpl::Flush() + { + vgFlush(); + } + +/** + @see CDirectGdiDriver::Finish() + */ +void CDirectGdiDriverImpl::Finish() + { + // Call eglWaitClient() instead of vgFinish() because MBX EGL implementation currently + // does nothing with a vgFinish(). + if (eglWaitClient() == EGL_FALSE) + { + TInt err = KErrNone; + HANDLE_EGL_ERROR(err, EDirectGdiPanicFinish); + SetError(err); + } + + } + +/** +@see CDirectGdiDriver::GetError() + +If no error has been reported explicitly, or SetError() has not been called, it will instead return +the first (if any) OpenVG error to occur since GetError() was last called. +*/ +TInt CDirectGdiDriverImpl::GetError() + { + // Call vgGetError() even when iErrorCode is already set, so that any OpenVG error state is + // cleared and not reported in future. + const TInt vgErrorCode = GetVgError(); + + if (iErrorCode == KErrNone) + { + iErrorCode = vgErrorCode; + } + TInt error = iErrorCode; + iErrorCode = KErrNone; + return error; + } + +/** +@see CDirectGdiDriver::CreateDrawableSource() + +For image resource creates a DirectGDI adaptation-specific resource from the given RSgDrawable resource so +it can be drawn using the DirectGDI rendering API. Creates an EGLImage, then a VGImage from the +passed RSgImage and associates the new source with these images. Sources that are successfully created +are added to an array of sources so that they can be closed and deleted correctly at a later stage. +Note that an image source cannot be created before an image target has been created and activated. +This is a limitation of OpenVG as a VG context must exist before an image source can be created. + +@param aHandleRet Handle of newly created drawable source, must be KNullHandle (is checked by generic driver). +@param aSgDrawable The RSgDrawable object to use when creating the drawable source. An attempt is made to +match the pixel format of the new EGL surface with the pixel format of this RSgImage. + +@pre CDirectGdiDriver object has been initialised from the calling thread and a target has been activated. + aHandleRet is KNullHandle. +@post The DirectGDI adaptation-specific resource that is bound to the given +drawable resource is created and this handle is now associated with it. The reference +counter on the drawable resource is incremented. The CDirectGdiDriver for this thread +is now aware of and owns the adaptation-specific resource. + +@return KErrNone if successful, KErrArgument if the drawable resource is not valid, +KErrNotSupported if the drawable resource is not created with the type (KSgImageTypeUid), +otherwise one of the system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::CreateDrawableSource(TInt& aHandleRet, const RSgDrawable& aSgDrawable) + { + TUid typeUid = aSgDrawable.DrawableType(); + if(typeUid != KSgImageTypeUid) + { + return KErrNotSupported; + } + const RSgImage* image = reinterpret_cast(&aSgDrawable); + CDirectGdiImageSourceImpl* imageSource = NULL; + TInt err = CDirectGdiImageSourceImpl::New(imageSource, *this, *image); + + if (err == KErrNone) + { + aHandleRet = reinterpret_cast(imageSource); + } + + return err; + } + +/** +@see CDirectGdiDriver::CreateDrawableSource() + +Destroys the DirectGDI adaptation-specific resource associated with this handle. +Calling this method on a handle that is not associated with any DirectGDI specific +resource will do nothing. Once Close() is called, this handle can be reused. The handle +is set to KNullHandle. + +@param aHandle A reference to a valid handle to a RDirectGdiDrawableSource object which is + to be closed. + +@pre CDirectGdiDriver object has been initialised from the calling thread. +@post The DirectGDI adaptation-specific resource associated with this handle will +be destroyed (at any time preferred by the adaptation). This handle is no longer +associated with a DirectGDI adaptation-specific resource. The reference counter of +the underlying drawable resource is decremented. aHandle is set to KNullHandle. + +@panic DGDIAdapter 37, if an image source cannot be created from the passed handle. +*/ +void CDirectGdiDriverImpl::CloseDrawableSource(TInt& aHandle) + { + CDirectGdiImageSourceImpl* imageSource = GetImageSourceFromHandle(aHandle); + GRAPHICS_ASSERT_ALWAYS(imageSource, EDirectGdiPanicCloseDrawableHandleFailure); + + // Decrement the reference count on this image source. If it reaches zero, it will + // remove itself from the source array and delete itself. + imageSource->Close(); + aHandle = KNullHandle; + } + + +/** +@see CDirectGdiDriver::CreateImageTarget() + +Allocates and constructs a CDirectGdiImageTargetImpl object, and associates it with aHandleRet. + +@param aHandleRet Handle of newly created Image Target, must be KNullHandle (is checked by generic driver). +@param aSgImage The RSgImage to associate with the created image target. An attempt is made to match +the pixel format of the new EGL surface with the pixel format of this RSgImage. + +@pre CDirectGdiDriver object has been initialised from the calling thread. +The image resource has been fully constructed and created with the correct usage +that allows it to be used as a DirectGDI target. aHandleRet is KNullHandle. + +@post The DirectGDI adaptation-specific resource that is bound to the given image +resource is created and this handle is now associated with it. The reference counter +on the image resource is incremented. + +@return KErrNone if successful, KErrArgument if the image resource is not valid, +KErrNotSupported if the image resource is not created with the correct +usage, otherwise one of the system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::CreateImageTarget(TInt& aHandleRet, const RSgImage& aSgImage) + { + CDirectGdiImageTargetImpl* imageTarget = NULL; + TInt err = CDirectGdiImageTargetImpl::New(imageTarget, *this, aSgImage, iPixelContextMap, iPixelConfigMap, iSharedContext); + + if (err == KErrNone) + { + // Return the handle to the newly created image target. + aHandleRet = reinterpret_cast(imageTarget); + } + + return err; + } + +/** +Destroys the DirectGDI adaptation-specific resource associated with this handle. +Calling this method on a handle that is not associated with any DirectGDI adaptation- +specific resource will do nothing. Once Close() is called, this handle can be reused. + +@param aHandle A handle to a RDirectGdiImageTarget object to be closed. + +@pre CDirectGdiDriver object has been initialised from the calling thread. + +@post The DirectGDI specific resource associated with this handle will be destroyed +if the reference count falls to zero. This handle is no longer associated with +a DirectGDI specific resource. The reference counter of the underlying image +resource is decremented. aHandle is set to KNullHandle. + +@panic DGDIAdapter 37, if the image source associated with aHandle is NULL. +*/ +void CDirectGdiDriverImpl::CloseImageTarget(TInt& aHandle) + { + CDirectGdiImageTargetImpl* imageTarget = GetImageTargetFromHandle(aHandle); + GRAPHICS_ASSERT_ALWAYS(imageTarget, EDirectGdiPanicCloseDrawableHandleFailure); + + // Decrement the reference count on this image target. If the reference count reaches zero, + // it is deleted and removed from the targets array. + imageTarget->Close(); + aHandle = KNullHandle; + } + +/** +Instantiates an adaptation-specific rendering engine. + +@param aDirectGdiEngine Reference to instantiated engine. + +@pre CDirectGdiDriver object has been initialised from the calling thread. + +@return KErrNone if the engine is constructed, else KErrNoMemory. +*/ +TInt CDirectGdiDriverImpl::CreateEngine(MDirectGdiEngine*& aDirectGdiEngine) + { + TInt result = KErrNone; + aDirectGdiEngine = new CVgEngine(*this); + if (aDirectGdiEngine == NULL) + { + result = KErrNoMemory; + } + return result; + } + +/** +Unbinds target from rendering engine and marks it for deletion. +NOTE: Currently this means just deleting the engine. + +@param aDirectGdiEngine Engine to operate on. + +@pre CDirectGdiDriver object has been initialised from the calling thread. + +@panic DGDIAdapter 38, if the engine is NULL. +*/ +void CDirectGdiDriverImpl::DestroyEngine(MDirectGdiEngine* aDirectGdiEngine) + { + GRAPHICS_ASSERT_ALWAYS(aDirectGdiEngine, EDirectGdiPanicDestroyNullEngine); + CVgEngine* actualEngine = static_cast(aDirectGdiEngine); + delete actualEngine; + } + +/** +The only extension interface supported by this implementation is MDirectGdiDriverCacheSize. + +@see CDirectGdiDriver::GetInterface() + */ +TInt CDirectGdiDriverImpl::GetInterface(TUid aInterfaceId, TAny*& aInterface) + { + aInterface = NULL; + TInt err = KErrNone; + switch (aInterfaceId.iUid) + { + case KDirectGdiDriverCacheSizeUid: + { + aInterface = static_cast(this); + break; + } + default: + err = KErrExtensionNotSupported; + break; + } + return err; + } + +CDirectGdiDriverImpl::CDirectGdiDriverImpl(RLibrary aLibrary) + : CDirectGdiDriverInternal(aLibrary), + iDisplay(EGL_NO_DISPLAY) + { + } +/** +Performs the second phase of construction. + +@pre CDirectGdiDriver object has been initialised from the calling thread. +@post EGL has been initialised. SgDriver has been opened. + +@panic DGDIAdapter 36, if eglGetDisplay() fails. +@panic DGDIAdapter 35, if eglInitialize() fails. +@panic DGDIAdapter 23, if eglBindAPI() fails. +@return KErrNone if successful, KErrNotFound if no implementation of the Graphics Resource API is found, + KErrNotSupported if the version of EGL is less than required (1.2), otherwise one of the + system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::Construct() + { + TInt err = KErrNone; + iSharedContext = EGL_NO_CONTEXT; + + // First thing is to check whether the mutex for the Process State was successfully created. + // If not, it's a fatal error. If it is, we must increment the reference count on the mutex as + // early as possible to make the creation/destruction of the display thread-safe. + err = ProcessState().MutexCreationStatus(); + if (err == KErrNone) + { + ProcessState().OpenDriver(); + } + + if (err == KErrNone) + { + err = SgDriver::Open(); + } + + if (err == KErrNone) + { + // Create display object + iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); + GRAPHICS_ASSERT_ALWAYS(iDisplay != EGL_NO_DISPLAY, EDirectGdiPanicNoDisplay); + + // Initialise the display. If it is already initialised, EGL will return quickly. + EGLint major, minor; + if (!eglInitialize(iDisplay, &major, &minor)) + { + iDisplay = EGL_NO_DISPLAY; + HANDLE_EGL_ERROR(err, EDirectGdiPanicInitializeDisplay); + } + else if (major < 1 || (major == 1 && minor < 2)) + { + // Atleast EGL 1.2 needs to be available. + err = KErrNotSupported; + } + } + + if (err == KErrNone) + { + // Let EGL know we will use it for OpenVG + if(!eglBindAPI(EGL_OPENVG_API)) + { + HANDLE_EGL_ERROR(err, EDirectGdiPanicBindApi); + } + } + + if (err == KErrNone) + { + iGlyphImageStorage = new CFontGlyphImageStorage(KDirectGdiAdapterDefaultMaxGlyphImageCacheSize); + if(!iGlyphImageStorage) + { + err = KErrNoMemory; + } + } + + if (err == KErrNone) + { + iVgImageCache = new CVgImageCache(KDirectGdiAdapterDefaultMaxImageCacheSize); + if(!iVgImageCache) + { + err = KErrNoMemory; + } + } + + if (err == KErrNone) + { + err = ProcessState().Initialize(iDisplay); + } + + if (err == KErrNone) + { + err = InitializeEglConfigs(iDisplay); + } + + return err; + } + +/** +@see CDirectGdiDriver::SetError() + +In the event that OpenVG's error state has been set, it will be used as the driver's error state, +overriding aErr. + +@param aErr The error code to be set. +@pre CDirectGdiDriver object has been initialised from the calling thread. +@post The error state is set to the current OpenVG error state, otherwise aErr, if the current error state + is empty. +*/ +void CDirectGdiDriverImpl::SetError(TInt aErr) + { + if( iErrorCode == KErrNone ) + { + iErrorCode = GetVgError(); + if (iErrorCode == KErrNone) + { + iErrorCode = aErr; + } + } + } + +/** +Static function. Converts the current OpenVG error state (if any) to a standard Symbian error code. + +@panic DGDIAdapter 64, if the error code received from OpenVG is due to misuse of OpenVG rather + than a runtime error. +@return KErrGeneral if the OpenVG error code not recognised, otherwise a system-wide error +code converted from the OpenVG error code. +*/ +TInt CDirectGdiDriverImpl::GetVgError() + { + TInt error = KErrGeneral; + switch(vgGetError()) + { + case VG_NO_ERROR: + error = KErrNone; + break; + case VG_BAD_HANDLE_ERROR: + error = KErrBadHandle; + break; + case VG_ILLEGAL_ARGUMENT_ERROR: + error = KErrArgument; + break; + case VG_OUT_OF_MEMORY_ERROR: + error = KErrNoMemory; + break; + default: + // Any other error is due to DirectGDI using OpenVG incorrectly somewhere. + GRAPHICS_PANIC_DEBUG(EDirectGdiPanicVgError); + } + return error; + } + +/** +Sets the current engine as the most recent engine which has been activated. + +@param aCurrentEngine The pointer to the most recent engine. +*/ +void CDirectGdiDriverImpl::SetCurrentEngine(CVgEngine* aCurrentEngine) + { + iCurrentEngine = aCurrentEngine; + } + +/** +Checks whether the given engine is current or not, so that the OpenVG state can be reset. + +@param aCurrentEngine The pointer to an engine. +@return ETrue if it is the current engine, else EFalse. +*/ +TBool CDirectGdiDriverImpl::IsCurrentEngine(const CVgEngine* aCurrentEngine) const + { + return (iCurrentEngine == aCurrentEngine); + } + +/** +Checks whether this target is current or not, so that the EGL state can be reset. + +@param aCurrentTarget The pointer to a target. +@return ETrue if it is the current target, else EFalse. +*/ +TBool CDirectGdiDriverImpl::IsCurrentTarget(const CDirectGdiImageTargetImpl* aCurrentTarget) const + { + return (iCurrentTarget == aCurrentTarget); + } + +/** +Sets the current target as the most recent target which has been activated. + +@param aCurrentTarget The pointer to the most recent target. +*/ +void CDirectGdiDriverImpl::SetCurrentTarget(CDirectGdiImageTargetImpl* aCurrentTarget) + { + iCurrentTarget = aCurrentTarget; + } + +/** +Activates the specified target and increments its reference count as it can be shared across many +DirectGDI contexts. + +@param aRenderingTarget The target object which is to be activated. +*/ +void CDirectGdiDriverImpl::Activate(CDirectGdiImageTargetImpl* aRenderingTarget) + { + // Reactivate() does the same activation + Reactivate(aRenderingTarget); + aRenderingTarget->Open(); + } + +/** +Reactivates the specified target, without affecting its reference count. + +@param aRenderingTarget The target to be reactivated. + +@panic DGDIAdapter 2, if eglGetError() returns an error we can't handle. +*/ +void CDirectGdiDriverImpl::Reactivate(CDirectGdiImageTargetImpl* aRenderingTarget) + { + if(!aRenderingTarget->Activate()) + { + TInt error = KErrNone; + HANDLE_EGL_ERROR(error, EDirectGdiPanicUnexpectedError); + if(error == KErrNoMemory) + { + SetError(error); + } + // Can check here whether error == KErrDied, which signifies an EGL_CONTEXT_LOST error. + // due to a power management event. Then need to destroy and recreate all EGLContexts used. + // This is not implemented as the EGL used with this reference adaptation does not produce this error. + // Following pseudocode will achieve this: + // 1. For each context stored in iPixelMapContext: + // 1a. Destroy context. + // 1b. Create replacement context with same parameters. + // 1c. Search through all rendering targets replacing the context stored (if it matches with the one just destroyed) with the new one. + // 2. Try activating the rendering target again. + } + } + +/** +Deactivates the target if it was the current target, and decrements its reference count as it can +be shared across many DirectGDI contexts. + +@param aRenderingTarget The target object which you want to deactivate. +*/ +void CDirectGdiDriverImpl::Deactivate(CDirectGdiImageTargetImpl* aRenderingTarget) + { + aRenderingTarget->Close(); + } + +/** +Helper function for removing a pointer to a CDirectGdiImageRef object from the source image array. +@param aImage A pointer to a CDirectGdiImageRef source object. +@return KErrNone if successful, KErrNotFound if no suitable object pointer can be found, +otherwise one of the other system wide error codes. + */ +TInt CDirectGdiDriverImpl::UnregisterSourceImage(const CDirectGdiImageSourceImpl& aImage) + { + TInt index = -1; + TInt err = iSourceArray.FindInAddressOrder(&aImage, index); + if (err == KErrNone) + { + iSourceArray.Remove(index); + iSourceArray.GranularCompress(); + } + + return err; + } + +/** +Helper function for removing a pointer to a CDirectGdiImageRef object from the target image array. +@param aImage A pointer to a CDirectGdiImageRef source object. +@return KErrNone if successful, KErrNotFound if no suitable object pointer can be found, +otherwise one of the other system wide error codes. + */ +TInt CDirectGdiDriverImpl::UnregisterTargetImage(const CDirectGdiImageTargetImpl& aImage) + { + TInt index = -1; + TInt err = iTargetArray.FindInAddressOrder(&aImage, index); + if (err == KErrNone) + { + iTargetArray.Remove(index); + iTargetArray.GranularCompress(); + } + + return err; + } + +/** +Helper function to convert a handle for a RDirectGdiDrawableSource object to a CDirectGdiImageSourceImpl +object. In debug builds, it also checks that the image source was actually created by this driver and +exists in the array of image sources. + +@param aHandle A valid handle to a RDirectGdiDrawableSource object. +@return A pointer to a CDirectGdiImageSourceImpl object that the handle represents. +*/ +CDirectGdiImageSourceImpl* CDirectGdiDriverImpl::GetImageSourceFromHandle(TInt aHandle) const + { +#ifdef _DEBUG + CheckSourceIsValid(aHandle); +#endif // _DEBUG + + CDirectGdiImageSourceImpl* source = reinterpret_cast(aHandle); + return source; + } + +/** +Helper function to convert a handle for a RDirectGdiImageTarget object to a CDirectGdiImageTargetImpl +object. In debug builds, it also checks that the image target was actually created by this driver and +exists in the array of image target. + +@param aHandle A valid handle to a RDirectGdiImageTarget object. +@return A pointer to a CDirectGdiImageTargetImpl object that the handle represents. +*/ +CDirectGdiImageTargetImpl* CDirectGdiDriverImpl::GetImageTargetFromHandle(TInt aHandle) const + { +#ifdef _DEBUG + CheckTargetIsValid(aHandle); +#endif // _DEBUG + + CDirectGdiImageTargetImpl* target = reinterpret_cast(aHandle); + return target; + } + +/** +Allows the engine to check whether a resource is an image source or not, given its handle. +If the image is an image source, it will be in the array of image sources. + +@param aHandle The handle to check for being an image source. +@return ETrue if the passed handle is for an image source, EFalse otherwise. + */ +TBool CDirectGdiDriverImpl::IsImageSource(TInt aHandle) const + { + CDirectGdiImageRef* source = reinterpret_cast(aHandle); + TInt index = -1; + return (iSourceArray.FindInAddressOrder(source, index) == KErrNone); + } + +#ifdef _DEBUG +/** +Debug-only helper function to check that a source object has been created by this driver. +If it has been created by this driver it will exist in the source array. + +@panic DGDIAdapter 32, if the source can not be found in the source array. +*/ +void CDirectGdiDriverImpl::CheckSourceIsValid(TInt aHandle) const + { + // Debug only check to make sure the handle exists in the array of source objects + // that have been created by this driver + CDirectGdiImageRef* source = reinterpret_cast(aHandle); + TInt index = -1; + TInt err = iSourceArray.FindInAddressOrder(source, index); + GRAPHICS_ASSERT_ALWAYS(err == KErrNone, EDirectGdiPanicResourceHandleNotFound); + } + +/** +Debug-only helper function to check that a target object has been created by this driver. +If it has been created by this driver it will exist in the target array. + +@panic DGDIAdapter 32, if the target is not found in the target array. + */ +void CDirectGdiDriverImpl::CheckTargetIsValid(TInt aHandle) const + { + // Debug only check to make sure the handle exists in the array of target objects + // that have been created by this driver + CDirectGdiImageRef* target = reinterpret_cast(aHandle); + TInt index = -1; + TInt err = iTargetArray.FindInAddressOrder(target, index); + GRAPHICS_ASSERT_ALWAYS(err == KErrNone, EDirectGdiPanicResourceHandleNotFound); + } +#endif // _DEBUG + +// VGImage cache APIs + +/** +@see CVgImageCache::GetVgImageFromCache() + */ +VGImage CDirectGdiDriverImpl::GetVgImageFromCache(const CFbsBitmap& aBitmap, const TPoint& aOrigin) const + { + return iVgImageCache->GetVgImageFromBitmap(aBitmap, aOrigin); + } + +/** +@see CVgImageCache::AddImage() + */ +TBool CDirectGdiDriverImpl::AddVgImageToCache(const CFbsBitmap& aBitmap, VGImage& aImage, const TPoint& aOrigin) + { + return iVgImageCache->AddImage(aBitmap, aImage, aOrigin); + } + +/** +Gets the VGImage cache. +@return The VGImage cache. +*/ +CVgImageCache* CDirectGdiDriverImpl::VgImageCache() const + { + return iVgImageCache; + } + +/** +Gets the Glyph image storage. +@return The Glyph image storage. +*/ +CFontGlyphImageStorage* CDirectGdiDriverImpl::FontGlyphImageStorage() const + { + return iGlyphImageStorage; + } + +/** +Creates VG images which will be used to draw glyphs if the system runs out of memory +*/ +TInt CDirectGdiDriverImpl::PreAllocateFontGlyphImages() + { + TInt res = KErrNotReady; + if(iGlyphImageStorage) + { + res = iGlyphImageStorage->PreAllocateImages(); + if(res == KErrNoMemory) + {//try to clean bitmap cache + iVgImageCache->ResetCache(); + res = iGlyphImageStorage->PreAllocateImages(); + if(res == KErrNoMemory) + {//try to clean glyph image cache + iGlyphImageStorage->CleanGlyphImageCache(); + res = iGlyphImageStorage->PreAllocateImages(); + } + } + } + return res; + } + +/** +Registers the image source with this driver, by adding it to a list of internal image sources. +@param aImage The image to register. +@return KErrNone if successful, otherwise on of the system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::RegisterSourceImage(const CDirectGdiImageSourceImpl& aImage) + { + return iSourceArray.InsertInAddressOrder(&aImage); + } + +/** +Registers the image target with this driver, by adding it to a list of internal image targets. +@param aImage The image to register. +@return KErrNone if successful, otherwise on of the system-wide error codes. +*/ +TInt CDirectGdiDriverImpl::RegisterTargetImage(const CDirectGdiImageTargetImpl& aImage) + { + return iTargetArray.InsertInAddressOrder(&aImage); + } + +/** +@see MDirectGdiDriverCacheSize::SetMaxImageCacheSize() + */ +TInt CDirectGdiDriverImpl::SetMaxImageCacheSize(TInt aSize) + { + return iVgImageCache->SetMaxCacheSize(aSize); + } + +/** +@see MDirectGdiDriverCacheSize::MaxImageCacheSize() + */ +TInt CDirectGdiDriverImpl::MaxImageCacheSize() const + { + return iVgImageCache->MaxCacheSize(); + } + +/** +@see MDirectGdiDriverCacheSize::SetMaxGlyphCacheSize() + */ +TInt CDirectGdiDriverImpl::SetMaxGlyphCacheSize(TInt aSize) + { + return iGlyphImageStorage->SetMaxGlyphCacheSize(aSize); + } + +/** +@see MDirectGdiDriverCacheSize::MaxGlyphCacheSize() + */ +TInt CDirectGdiDriverImpl::MaxGlyphCacheSize() const + { + return iGlyphImageStorage->MaxGlyphCacheSize(); + }