// 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:

// Declaration of a Direct Graphics Device Interface (GDI) Driver implementation,

// this class actually implements the HAI.

// 

//

#ifndef __DIRECTGDIDRIVERIMPL_H__

#define __DIRECTGDIDRIVERIMPL_H__

/**

@file

@internalComponent Reference implementation of Open VG hardware accelerated DirectGDI adaptation.

*/

#include "vgimagecache.h"

#include "directgdidrawableref.h"

#include "directgdiimageref.h"

#include "directgdidriverprocessstate.h"

#include "glyphimagecache.h"

#include <graphics/directgdidriverinternal.h>

#include <graphics/directgdiextensioninterfaces.h>

#include <e32hashtab.h>

#include <e32cmn.h>

#include <pls.h>

// Forward declarations.

//

class CDirectGdiImageTargetImpl;

class CDirectGdiImageSourceImpl;

class CVgEngine;

class CDirectGdiDrawableRef;

class RDirectGdiImageTarget;

/**

Represents the body part of CDirectGdiDriver that actually implements the HAI. Derives from the CDirectGdiDriverInternal class and implements all the 

interfaces to provide the functionality required by the generic layer.

*/

NONSHARABLE_CLASS(CDirectGdiDriverImpl): public CDirectGdiDriverInternal, public MDirectGdiDriverCacheSize

	{

public:

	static TInt New(CDirectGdiDriverInternal*& aInternal, RLibrary aLibrary);

	~CDirectGdiDriverImpl();

	// From CDirectGdiDriverInternal	

	void Flush();

	void Finish();	

	TInt GetError();

	void SetError(TInt aErr);

	TInt CreateDrawableSource(TInt& aHandleRet, const RSgDrawable& aSgDrawable);

	void CloseDrawableSource(TInt& aHandle) ;	

	TInt CreateImageTarget(TInt& aHandleRet, const RSgImage& aImageDestination);

	void CloseImageTarget(TInt& aHandle);

	TInt CreateEngine(MDirectGdiEngine*& aDirectGdiEngine);

	void DestroyEngine(MDirectGdiEngine* aDirectGdiEngine);

	TInt GetInterface(TUid aInterfaceId, TAny*& aInterface);

	// From MDirectGdiDriverCacheSize

	TInt SetMaxImageCacheSize(TInt aSize);	

	TInt MaxImageCacheSize() const;

	TInt SetMaxGlyphCacheSize(TInt aSize);

	TInt MaxGlyphCacheSize() const;

	void SetCurrentEngine(CVgEngine* aCurrentEngine);

	void SetCurrentTarget(CDirectGdiImageTargetImpl* aCurrentTarget);

	TBool IsCurrentEngine(const CVgEngine* aCurrentEngine) const;

	TBool IsCurrentTarget(const CDirectGdiImageTargetImpl* aCurrentTarget) const;

	void Activate(CDirectGdiImageTargetImpl* aRenderingTarget);

	void Reactivate(CDirectGdiImageTargetImpl* aRenderingTarget);

	void Deactivate(CDirectGdiImageTargetImpl* aRenderingTarget);

	CDirectGdiImageSourceImpl* GetImageSourceFromHandle(TInt aHandle) const;	

	CDirectGdiImageTargetImpl* GetImageTargetFromHandle(TInt aHandle) const;

	TBool IsImageSource(TInt aHandle) const;

	CFontGlyphImageStorage* FontGlyphImageStorage() const;

	TInt PreAllocateFontGlyphImages(); //images will be used to draw glyphs if the system runs out of memory

	CVgImageCache* VgImageCache() const;

	// VGImage cache commands

	VGImage GetVgImageFromCache(const CFbsBitmap& aBitmap, const TPoint& aOrigin) const;

	TBool AddVgImageToCache(const CFbsBitmap& aBitmap, VGImage& aImage, const TPoint& aOrigin);

	TInt RegisterSourceImage(const CDirectGdiImageSourceImpl& aImage);

	TInt RegisterTargetImage(const CDirectGdiImageTargetImpl& aImage);

	TInt UnregisterSourceImage(const CDirectGdiImageSourceImpl& aImage);

	TInt UnregisterTargetImage(const CDirectGdiImageTargetImpl& aImage);

	inline EGLDisplay EglDisplay() const;

	inline XDirectGdiDriverProcessState& ProcessState() const;

	static TInt GetVgError();

private:

	CDirectGdiDriverImpl(RLibrary aLibrary);

	TInt Construct();

	TInt InitializeEglConfigs(EGLDisplay display);

#ifdef _DEBUG

	void CheckSourceIsValid(TInt aHandle) const;

	void CheckTargetIsValid(TInt aHandle) const;

#endif // _DEBUG

private:

	TInt iErrorCode; 	/**< The first error code to occur in any CVgEngine instance.*/

	RHashMap<TInt, EGLContext> iPixelContextMap;

	RHashMap<TInt, EGLConfig> iPixelConfigMap;

	CVgEngine* iCurrentEngine;

	CDirectGdiImageTargetImpl* iCurrentTarget;

	EGLContext iSharedContext;

	EGLDisplay iDisplay;

	RPointerArray<CDirectGdiImageRef> iSourceArray;	/**< An array of pointers to all sources created and currently held open by this driver.*/

	RPointerArray<CDirectGdiImageRef> iTargetArray;	/**< An array of pointers to all targets created and currently held open by this driver.*/

	CFontGlyphImageStorage* iGlyphImageStorage;

	CVgImageCache* iVgImageCache;

#ifndef __WINS__

	static XDirectGdiDriverProcessState gProcessState;

#endif

	};

/**

@return A reference to the process state object.

*/

inline XDirectGdiDriverProcessState& CDirectGdiDriverImpl::ProcessState() const

	{

#ifdef __WINS__

	const TUid KDirectGdiAdapterUid = {0x102858E9};

	return *Pls<XDirectGdiDriverProcessState>(KDirectGdiAdapterUid);

#else

	return gProcessState;

#endif

	}

/**

@return A handle to the EGLDisplay associated with this driver.

*/

inline EGLDisplay CDirectGdiDriverImpl::EglDisplay() const 

	{

	return iDisplay; 

	}

#endif //__DIRECTGDIDRIVERIMPL_H__