// 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 "directgdipaniccodes.h" // Included first to resolve dependency

 #include <graphics/sgimage.h>

 #include <graphics/directgdiimagetarget.h>

 #include <graphics/directgdidrawablesource.h>

 #include <graphics/directgdipanics.h>

 #include <graphics/directgdidriverinternal.h>

 #include <e32svr.h>

 #include <u32hal.h>

 #include "directgdidriver.h"

 #include "directgditypes.h"

 #include "directgdidriverinternallibrary.inl"

 typedef TInt (*TDriverCreateFunction)(CDirectGdiDriverInternal*&, RLibrary);

 /**

 Returns the singleton instance of CDirectGdiDriver for the calling thread. 

 @return Pointer to an opened CDirectGdiDriver object else NULL if a CDirectGdiDriver had not been opened yet.

 */

 EXPORT_C CDirectGdiDriver* CDirectGdiDriver::Static()

 	{

 	return static_cast<CDirectGdiDriver*>(Dll::Tls());						

 	}

 /**

 Creates a new CDirectGdiDriver object if one has not already been created in this thread.

 Performs any adaptation initialisation that is needed to allow the calling thread to use 

 functionality provided by the new DirectGDI interfaces. Calling this method multiple times 

 from the same client thread has no effect after the first call, other than to increase the 

 open count. 

 @see CDirectGdiDriver::Close()

 @pre None.

 @post The object reference counter is incremented. Adaptation resources for the 

 calling thread are created and initialised. The new DirectGDI interfaces are ready 

 to be used from the calling thread.  

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

 */

 EXPORT_C TInt CDirectGdiDriver::Open()

 	{

 	TInt err = KErrNone;

 	CDirectGdiDriver* self = Static(); 

 	// Check we're not already opened

 	if (!self)

 		{				

 		self = new CDirectGdiDriver();

 		if (!self)

 			{

 			err = KErrNoMemory;

 			return err;

 			}

 #ifdef __WINS__

 		// Dynamically load DirectGDI adapter library.

 		// Under WINS two dlls will be available - directgdiadapter_sw.dll and directgdiadapter_vg.dll

 		// Need to select which dll to load.  The value of the keyword SYMBIAN_GRAPHICS_DIRECTGDI_USE

 		// in the epoc.ini file will determine the dll to load.

 		// If this keyword does not appear in the epoc.ini file, the software version of

 		// directgdiadapter will be loaded by default.

 		_LIT(KVgAdapterDllName, "directgdiadapter_vg.dll");

 		_LIT(KSwAdapterDllName, "directgdiadapter_sw.dll");

 		TBool useOpenVg = EFalse;

 		UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalBoolProperty,  (TAny*)"symbian_graphics_directgdi_use_openvg",  &useOpenVg);

 		TPtrC libraryName;

 		if(useOpenVg)

 			{

 			libraryName.Set(KVgAdapterDllName);

 			}

 		else

 			{

 			libraryName.Set(KSwAdapterDllName);

 			}

 		RLibrary lib;

 		err = lib.Load(libraryName);

 		if (err != KErrNone)

 			{

 			delete self;

 			return (err==KErrNotFound ? KErrNotSupported : err);

 			}

 		// Create internal driver

 		err = self->CreateInternalDriver(lib);

 		if (err != KErrNone)

 			{

 			delete self;

 			lib.Close();

 			return err;

 			}

 #else

 		// Under armv5, the appropriate dll (software or vg) is determined at rom build time.

 		err = self->CreateInternalDriver();

 		if (err != KErrNone)

 			{

 			delete self;

 			return err;

 			}

 #endif

 		// Store a pointer to the new driver instance in thread local storage:

 		err = Dll::SetTls(self);

 		if (err != KErrNone)	

 			{

 			delete self;

 			}				

 		}

 	if (err == KErrNone)

 		{

 		++(self->iOpenCount);

 		}

 	return err;

 	}

 /**

 Create the adaptation/internal object for this driver.

 @pre The adaptation/internal driver object has not been created yet.

 @post The adaptation/internal object has been created.

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

  */

 #ifdef __WINS__

 TInt CDirectGdiDriver::CreateInternalDriver(const RLibrary& aLibrary)

 	{

 	// Function at ordinal 1 creates new CDirectGdiDriverInternal

 	TDriverCreateFunction create = reinterpret_cast<TDriverCreateFunction>(aLibrary.Lookup(1));

 	return create(iDriverInternal, aLibrary);

 	}

 #else

 TInt CDirectGdiDriver::CreateInternalDriver()

 	{

 	return CDirectGdiDriverInternal::New(iDriverInternal, RLibrary());

 	}

 #endif

 /**

 Performs adaptation termination which is needed to release any internal resources 

 allocated by the calling thread. It will also perform an implicit Finish() by submitting

 all outstanding requests from the calling thread. A DirectGDI client's thread that 

 uses the new DirectGDI interfaces must call this method at the end of its lifetime.

 @see CDirectGdiDriver::Open()

 @pre The driver is open from a call to Open().

 @post The object open count is decremented. If the open count reaches zero, any 

 adaptation resources allocated to the calling thread must be released, and the CDirectGdiDriver 

 object for the calling thread is destroyed.

 @panic DGDI 14, if Close() is called on a CDirectGdiDriver object that is not open.

 */

 EXPORT_C void CDirectGdiDriver::Close()

 	{	

 	GRAPHICS_ASSERT_ALWAYS(iOpenCount > 0, EDirectGdiPanicDriverOpenCountError);

 	if (--iOpenCount == 0)

 		{

 		// We call Finish() instead of Flush() because it will decrease the reference count

 		// of images used in DrawResource() (if any) and is guaranteed that it will complete.

 		// Flush() cannot guarantee completion so we can't decrement image reference counts.

 		Finish();

 		// Get the handle to the DLL used by iDriverInternal so that we can close

 		// it once iDriverInternal has been deleted.

 		RLibrary lib = iDriverInternal->Library();

 		delete this;

 		lib.Close();

 		// Free the space we saved for the driver singleton pointer in thead local storage

 		Dll::FreeTls();		

 		}		

 	}

 /**

 Ensures all outstanding requests on the calling thread are submitted for processing.

 The method immediately returns and does not wait until all outstanding requests are

 completely processed. Clients can continue issuing rendering requests after calling

 this method.

 @see    CDirectGdiDriver::Finish()

 @pre 	CDirectGdiDriver object has been initialised for the calling thread.

 @post 	All outstanding requests have been submitted for processing.

 */

 EXPORT_C void CDirectGdiDriver::Flush()

 	{

 	iDriverInternal->Flush();

 	}

 /**

 Ensures all outstanding rendering requests from the calling thread are submitted

 and processed. This method will wait until all the outstanding rendering requests

 have been completely processed.

 @see    CDirectGdiDriver::Flush()

 @pre 	CDirectGdiDriver object has been initialised for the calling thread.

 @post 	All outstanding requests have been completely processed.

 */

 EXPORT_C void CDirectGdiDriver::Finish()

 	{

 	iDriverInternal->Finish();

 	}

 /**

 Returns the first error code (as the result of calling any DirectGDI API), if any,

 since the last call to this function or, if it has not previously been called, since

 the CDirectGdiDriver was initialised. Calling this function clears the error code.

 @see    CDirectGdiDriver::SetError(TInt)

 @pre 	CDirectGdiDriver object has been initialised for the calling thread.

 @post 	The error code has been reset after being read.

 @return The first error code, if any, since the last call to this function or, 

 		if it has not previously been called, since the CDirectGdiDriver was initialised. 

 		KErrNone will indicate that no such error has occurred.

 */

 EXPORT_C TInt CDirectGdiDriver::GetError()

 	{

 	return iDriverInternal->GetError();

 	}

 /**

 Sets the error code on the driver. If the error code is already set to a value other

 than KErrNone, the error code will not be modified.

 @see    CDirectGdiDriver::GetError()

 @param  aErr The error code to set.

 @pre 	CDirectGdiDriver object has been initialised for the calling thread.

 @post 	The error code has been set.

 */

 EXPORT_C void CDirectGdiDriver::SetError(TInt aErr)

 	{

 	iDriverInternal->SetError(aErr);

 	}

 /**

 Retrieves a pointer to an instance of the requested extension interface implementation, if provided.

 @param	aInterfaceId The globally unique identifier of the requested interface.	

 @param	aInterface On return, holds the specified interface, or NULL if the interface cannot be found.

 @pre	CDirectGdiDriver object has been initialised for the calling thread.

 @return KErrNone If the interface is supported, KErrExtensionNotSupported otherwise.

  */

 EXPORT_C TInt CDirectGdiDriver::GetInterface(TUid aInterfaceId, TAny*& aInterface)

 	{

 	return iDriverInternal->GetInterface(aInterfaceId, aInterface);

 	}

 /**

 CDirectGdiDriver private constructor as this class is singleton.

 @pre 	None.

 @post 	Initialises the member reference counter to zero.

 */

 CDirectGdiDriver::CDirectGdiDriver()

 	{	

 	}

 /**

 CDirectGdiDriver default destructor.

 @pre None.

 @post None.

 @panic DGDI 15, if the resource count is not zero.

 */

 CDirectGdiDriver::~CDirectGdiDriver()

 	{

 	GRAPHICS_ASSERT_ALWAYS(iOpenCount == 0, EDirectGdiPanicDriverDestructorOpenCountError);

 	delete iDriverInternal;		

 	}

 /**

 Delegates the call to the CDirectGdiDriverInternal object, which creates a DirectGDI 

 adaptation-specific resource from the given drawable resource so it can be drawn 

 using the DirectGDI rendering API.

 @see CloseDrawableSource()

 @param 	aRDirectGdiDrawableSource The RDirectGdiDrawableSource object to be created

 @param 	aRSgDrawable The RSgDrawable object to use when creating aRDirectGdiDrawableSource

 @pre 	CDirectGdiDriver object has been initialised from the calling thread.

 @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, KErrNotSupported if the drawable resource is not 

 created with the correct usage (ESgUsageDirectGdiSource must be set), otherwise one of the system-wide error codes.

 @panic DGDI 19, if this handle is already associated with a DirectGDI adaptation-specific drawable resource.

 @panic DGDI 20, if the drawable resource is not valid.

 */

 TInt CDirectGdiDriver::CreateDrawableSource(RDirectGdiDrawableSource& aRDirectGdiDrawableSource, const RSgDrawable& aRSgDrawable)

 	{				

 	GRAPHICS_ASSERT_ALWAYS(aRDirectGdiDrawableSource.Handle() == KNullHandle, EDirectGdiPanicDrawableSourceAlreadyExists);

 	if(aRSgDrawable.DrawableType() == KSgImageTypeUid)

 		{// make sure that drawable was created with the flag ESgUsageDirectGdiSource

 		RSgImage *image = (RSgImage*) &aRSgDrawable;

 		TSgImageInfo info;

 		TInt err = image ->GetInfo (info);

 		GRAPHICS_ASSERT_ALWAYS(err == KErrNone, EDirectGdiPanicImageSourceInfoError);

 		if (!(info.iUsage & ESgUsageDirectGdiSource))

 			{

 			return KErrNotSupported;

 			}

 		}

 	return iDriverInternal->CreateDrawableSource(aRDirectGdiDrawableSource.iHandle, aRSgDrawable);

 	}

 /**

 Delegates call to the CDirectGdiDriverInternal object, which 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.

 @see CreateDrawableSource()

 @param 	aSource The RDirectGdiDrawableSource object.

 @pre 	CDirectGdiDriver object has been initialised from the calling thread.

 @post 	The DirectGDI 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 specific resource. The reference counter of the 

 underlying non-image resource is decremented. 

 */

 void CDirectGdiDriver::CloseDrawableSource(RDirectGdiDrawableSource& aSource)

 	{

 	iDriverInternal->CloseDrawableSource(aSource.iHandle);

 	}

 /**

 Delegates call to the CDirectGdiDriverInternal object, which creates a DirectGDI 

 adaptation-specific resource from the given image resource so it can be used as a 

 target of DirectGDI rendering.

 @see CloseImageTarget()

 @param 	aTarget The RDirectGdiImageTarget object.

 @param 	aImage The RSgImage object.

 @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.

 @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, KErrNotSupported if the image resource is not 

 created with the correct usage, otherwise one of the system-wide error codes.

 @panic DGDI 17, if this handle is already associated with a DirectGDI adaptation-specific resource.

 @panic DGDI 21, if the image resource is not valid.

 */

 TInt CDirectGdiDriver::CreateImageTarget(RDirectGdiImageTarget& aTarget, const RSgImage& aImage)

 	{		

 	GRAPHICS_ASSERT_ALWAYS(aTarget.Handle() == KNullHandle, EDirectGdiPanicImageTargetAlreadyExists);

     TSgImageInfo info;

 	TInt err = aImage.GetInfo(info);

 	GRAPHICS_ASSERT_ALWAYS(err == KErrNone, EDirectGdiPanicImageTargetInfoError);

 	if (!(info.iUsage & ESgUsageDirectGdiTarget))

 		{

 		return KErrNotSupported;

 		}

 	return iDriverInternal->CreateImageTarget(aTarget.iHandle, aImage);

 	}

 /**

 Delegates call to the CDirectGdiDriverInternal object, which 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.

 @see CreateImageTarget()

 @param 	aTarget The RDirectGdiImageTarget object.

 @pre 	CDirectGdiDriver object has been initialised from the calling thread.

 @post 	The DirectGDI 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 specific resource. The reference counter of the underlying image 

 resource is decremented. 

 */

 void CDirectGdiDriver::CloseImageTarget(RDirectGdiImageTarget& aTarget)

 	{

 	iDriverInternal->CloseImageTarget(aTarget.iHandle);

 	}

 /**

 Delegates call to the CDirectGdiDriverInternal object, which creates a

 MDirectGdiEngine object.

 @param 	aEngine The MDirectGdiEngine object.

 @pre 	CDirectGdiDriver object has been initialised from the calling thread.

 @post   None.

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

 */

 TInt CDirectGdiDriver::CreateEngine(MDirectGdiEngine*& aEngine)

 	{

 	return iDriverInternal->CreateEngine(aEngine);

 	}

 /**

 Delegates call to the CDirectGdiDriverInternal object, which destroys a

 MDirectGdiEngine object.

 @param 	aEngine The MDirectGdiEngine object.

 @pre 	CDirectGdiDriver object has been initialised from the calling thread.

 @post   None.

 */

 void CDirectGdiDriver::DestroyEngine(MDirectGdiEngine* aEngine)

 	{

 	iDriverInternal->DestroyEngine(aEngine);

 	}