// Copyright (c) 2006-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:

 //

 /**

  @file

  @publishedPartner

  @prototype

 */

 #ifndef __SURFACEMANAGER_DEV_H__

 #define __SURFACEMANAGER_DEV_H__

 #include <graphics/surface.h>

 #include "surfacemanagerdriver.h"

 #if 0

 #define TRACE(x) x

 #else

 #define TRACE(x)

 #endif

 /** Maximum number of HintPairs per surface */

 const TInt KMaxHintsPerSurface = 16;

 /** Maximum number of elements in the table. This value must be a power of 2 */

 #define KMaxLists 16

 /**

   Logical Device (factory class) for Surface manager

 */

 class DSurfaceManagerFactory : public DLogicalDevice

 	{

 public:

 	DSurfaceManagerFactory();

 	TInt Install();

 	void GetCaps(TDes8& aDes) const;

 	TInt Create(DLogicalChannelBase*& aChannel);

 	};

 /**

   Logical Channel class for SurfaceManager

 */

 class DSurfaceManagerChannel : public DLogicalChannelBase

 	{

 public:

 	DSurfaceManagerChannel();

 	~DSurfaceManagerChannel();

 	// Inherited from DLogicalChannelBase

 	TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

 	TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

 private:

 	// Implementation for the different kinds of messages sent through RBusLogicalChannel

 	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

 private:

 	DProcess* iOwner;

 	};

 /**

 Class to hold a reference count and process pointer. 

 Each surface has a linked list of these owning processes.

 The surface manager has a linked list of these to track connections.

 @internalTechnology

 */

 class TProcessListItem

 	{

 public:

 	TProcessListItem* iNext;	//pointer to next one in list

 	DProcess* iOwningProcess;	//pointer to the process object which is being reference counted

 	TInt iCount;				//reference count

 	};

 /**

 Class to hold the information about a surface.

 Each surface has a linked list of owners.  The surfaces are arranged in a linked list,

 with these objects being elements in the list.

 @internalTechnology

 */

 class TSurface					//one of these per surface

 	{

 public:

 	TSurface* iNext;			//singly linked list, points to next surface

 	TSurfaceId	iId;			//the surface id

 	TSize iSize;				//pixel width/height

 	TInt iBuffers;				//number of buffers

 	TUidPixelFormat iPixelFormat;			//pixel format

 	TInt iStride;				//offset from start of one line to the next, in bytes

 	TInt iOffsetToFirstBuffer;	//offset between the start of the surface memory and the start of the first pixel buffer

 	TInt iOffsetBetweenBuffers;	//offset between pixel buffers

 	TInt  iAlignment;			//byte alignment of the pixel buffers

 	TBool iContiguous;			//if it is in contiguous physical memory

 	DChunk* iChunk;				//ptr to the shared chunk

 	RSurfaceManager::TCacheAttribute iCacheAttrib;			//Caching attribute to create chunks memory

 	RSurfaceManager::THintPair iSurfaceHints[KMaxHintsPerSurface];	//Arbitrary key-value pairs associated with a surface

 	TBool iMappable;			//Is the Surface Mappable

 	TProcessListItem* iOwners;	//owner list. Singly linked list, points to next surface owner

 public:	

 	TProcessListItem* ProcessOwnerInfo(const DProcess* aProcess);

 	};

 /**

 Surface manager extension object.

 There is one static instance of this in the kernel extension.

 @internalTechnology

 */

 class DSurfaceManager : public DBase

 	{

 public:

 	TInt CreateSurface(const TDesC8* aConfig, TSurfaceId* aId);

 	TInt SurfaceInfo(const TSurfaceId* aId, TDes8* aInfo);

 	TInt OpenSurface(const TSurfaceId* aId);

 	TInt CloseSurface(const TSurfaceId* aId);

 	TInt MapSurface(const TSurfaceId* aId);

 	TInt AddConnection(const DProcess* iProcess);

 	void RemoveConnection(const DProcess* iProcess);

 	TInt CreateSurface(RSurfaceManagerDriver::TDeviceParam* aParam, TInt aChunkHandle);

 	TInt SynchronizeCache(RSurfaceManagerDriver::TDeviceParam* aId, RSurfaceManager::TSyncOperation aOperation);

 	TInt GetSurfaceHint(const TSurfaceId* aSurfaceId, RSurfaceManager::THintPair* aHintPair);

 	TInt SetSurfaceHint(const TSurfaceId* aSurfaceId, const RSurfaceManager::THintPair* aHintPair);

 	TInt AddSurfaceHint(const TSurfaceId* aSurfaceId, const RSurfaceManager::THintPair* aHintPair);

 	TInt GetBufferOffset(RSurfaceManagerDriver::TDeviceParam* aParam,TUint* aOffset);

 	TInt GetSurfaceManagerAttrib(RSurfaceManager::TSurfaceManagerAttrib* aAttrib,TInt* aValue);

 private:

 	void GenerateSurfaceId(TSurfaceId& aId);

 	TInt  CreateSurfaceChunk(const RSurfaceManager::TSurfaceCreationAttributes& attribs);

 	TInt ValidateAndCalculateChunkSize(RSurfaceManager::TSurfaceCreationAttributes& aAttribs, TInt& aOffset, 

 			TUint& aActualBufferSize, const TBool aNewChunk = EFalse);

 	TInt ValidatePhysicalMemory(DChunk* aChunk, const RSurfaceManager::TSurfaceCreationAttributes& aAttribs, 

 			TUint aBuffersize, TUint32& aMapAttr, TBool &aIsContiguous); 

 	TSurface* FindSurfaceById(const TSurfaceId& aId);

 	void CloseSurfaceHandlesForProcess(const DProcess* iProcess);

 	TProcessListItem* FindConnectedProcess(const DProcess* aProcess);

 	TInt FindHintKey(const RSurfaceManager::THintPair* aHints, TUint32 aKey) const;

 	TBool SortHints(RSurfaceManager::THintPair* aHints, TInt aNumberOfHints) const;

 	TInt InsertHintKey(RSurfaceManager::THintPair* aHints, const RSurfaceManager::THintPair& aHintPair) const;

 private:

 	TSurface* iSurfacesIndex[KMaxLists]; 			// A table with elements pointing to the head of each singly linked list

 	NFastMutex iMutex;						// Mutex to protect access to surface lists

 	TProcessListItem* iConnectedProcesses;	//reference counted list of processes connected to the driver

 	};

 #endif