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

#ifndef __UTILS_H__
#define __UTILS_H__

#include <e32std.h>
#include <gdi.h>
#include <fntstore.h>
#include <bitmap.h>
#include <sgresource/sgimage.h>

class RFbsSession;

/**
@internalComponent
*/ 
_LIT(KFBSERVPanicCategory,"FBSERV");
_LIT(KFBSERVGlobalThreadName,"!Fontbitmapserver");
_LIT(KFBSERVSharedChunkName,"FbsSharedChunk");
_LIT(KFBSERVLargeChunkName,"FbsLargeChunk");
#ifdef SYMBIAN_DEBUG_FBS_LOCKHEAP
_LIT(KFBSERVDebugMutexName,"FbsDebugMutex");
#endif

/**
@internalComponent
*/
const TUid KUidCFbsBitmapCreation={0x0009A2C};
/**
@internalComponent
*/
enum TFbsPanic
	{
	EFbsPanicNoConnection = 1,
	EFbsPanicBadConnection = 2,
	EFbsPanicUnknownMessage = 3,
	EFbsPanicActiveSchedulerError = 4,
	EFbsPanicStartupFailed = 5,
	EFbsTypefaceStoreError = 6,
	EFbsFontCreateFailed = 7,
	EFbsFontAddressViolation = 8,
	EFbsBitmapInvalidFormat = 9,
	EFbsBitmapInvalidMode = 10,
	EFbsBitmapInvalidCompression = 11,
	EFbsBitmapDecompressionError = 12,
	EFbsPanicChunkError = 13,
	EFbsColor256UtilError = 14,
	EFbsHardwareBitmapError = 15,
	EFbsNotSupportedForCompression = 16,
	EFbsBitmapAlignment = 17,
	EFbsBitmapInvalidScanLinePtr = 18,
	EFbsBitmapInvalidMode2 = 19,
	EFbsBitmapInvalidMode3 = 20,
	EFbsBitmapSwappingImpossible = 21,
	EFbsPanicBadHeapLock = 22,
	EFbsShaperNotYetCalled = 23,
	EFbsShaperInvalidArguments = 24,
	EFbsInvalidCompressionThreshold = 25,
	EFbsTypefaceIndexOutOfRange = 26,
	EFbsPanicBitmapDataCopy = 27,
	EFbsPanicBitmapReadOnly = 28,
	EFbsPanicFontNullHandle = 29,
    EFbsPanicGlyphDataIteratorClosed = 31,
	EFbsPanicGlyphMetricsArrayOutOfBounds = 32,
	EFbsPanicGlyphDataIteratorIndexOutOfRange = 33,
	EFbsPanicInvalidBitmapType = 35,
	EFbsPanicGlyphAtlasInconsistentState = 36,
	EFbsPanicGlyphDataIteratorFailedToOpenImage = 37,
	EFbsPanicGlyphDataIteratorInvalidState = 39,
	EFbsPanicGlyphMetricsArrayInvalidState = 40,
	};

class TScanLine
/**
@internalComponent
*/
	{
public:
	TPoint iPoint;
	TInt iLength;
	TDisplayMode iDispMode;
	};

class TBmpSpec
/**
@internalComponent
*/
	{
public:
	TSize iSizeInPixels;
	TDisplayMode iDispMode;
	TInt iHandle;
	TInt iServerHandle;
	TInt iAddressOffset;
	};

class TBmpHandles
/**
@internalComponent
*/
	{
public:
	TInt iHandle;
	TInt iServerHandle;
	TInt iAddressOffset;
	};

class TFontInfo
/**
@internalComponent
*/
	{
public:
	TInt iHandle;
	TInt iAddressOffset;
	TInt iServerHandle;
	};

class TSizeInfo
/**
@internalComponent
*/
	{
public:
	TSizeInfo(){}
	TSizeInfo(TInt aMaxHeight,TSize aDevSize):iMaxHeight(aMaxHeight),iDevSize(aDevSize) {}

	TInt iMaxHeight;
	TSize iDevSize;
	};

class TIntParcel
/**
@internalComponent
*/
	{
public:
	TInt iInt;
	};

class TLoadBitmapArg
/**
@internalComponent
*/
	{
public:
	TInt iBitmapId;
	TInt iShareIfLoaded;
	TInt iFileOffset;
	};


IMPORT_C extern const TInt KFbServLargeChunkGrowByShifter;
IMPORT_C extern const TInt KFbServLargeChunkSizeShifter;
IMPORT_C extern const TInt KFbServLargeChunkMinPhysicalSize;
IMPORT_C extern const TInt KFbServLargeChunkMinVirtualSize;
IMPORT_C extern const TInt KFbServLargeChunkMaxVirtualSize;


class CChunkPile : public CBase
/**
@internalComponent
*/
	{
public:
	IMPORT_C ~CChunkPile();
	IMPORT_C static CChunkPile* NewL(const RChunk& aChunk);
	IMPORT_C TUint8* Alloc(TInt aSize);
	IMPORT_C void Free(TAny* aCell);
	IMPORT_C TUint8* ChunkBase() const;
	IMPORT_C static TInt VirtualSize();
private:
	CChunkPile(const RChunk& aChunk);
	void ConstructL();
	TInt DoAlloc(TUint8*& aCell, TInt aSize, RPointerArray<TUint8>& aCells, RArray<TInt>& aFreeCellLinks, TBool aLarge);
	void DoFree(TUint8* aCell, RPointerArray<TUint8>& aCells, RArray<TInt>& aFreeCellLinks, TBool aLarge);
	TInt GrowSmallSection(TInt aSize, TInt aLastFreeCell);
	void ShrinkSmallSection(TInt aShrinkBy);
private:
	RChunk iChunk;
	TInt iPageSize;
	TInt iPageMask;
	RPointerArray<TUint8> iSmallCells; // last address is not a cell but the top of the small section
	RArray<TInt> iFreeSmallCellLinks; // index of Nth free small cell is element 0 + element 1 + ... + element N-1
	TInt iLargeSectionBottom; // boundary between small & large sections
	RPointerArray<TUint8> iLargeCells; // last address is not a cell but the top of the large section
	RArray<TInt> iFreeLargeCellLinks; // index of Nth free large cell is element 0 + element 1 + ... + element N-1
	RCriticalSection iLock;
	};

/**
Used to pass sizes of FBServs default heap, heap for large bitmaps, and heap for small bitmaps.

@internalComponent
@test
*/
struct THeapSizes
	{
	TInt iDefault;
	TInt iBig;
	TInt iSmall;
	};

/**
Used when the EFbsMessRasterize message is sent from client to server. Allows pointers to items
created on the shared FBServ heap to be passed from the server to the client as offsets from the
heap base. Valid pointers are recreated client side using these offsets combined with the client's
heap base.

@internalComponent 
 */
struct TRasterizeParams
	{
	TInt iMetricsOffset;
	TInt iBitmapPointerOffset;
	};

IMPORT_C extern const TInt KFbServWritableDataPagingMode;

/**
Used to specify the writable data paging mode of fbserv.
This may be set using the patchable constant KFbServWritableDataPagingMode at rom-build time via the definitions: 
	SYMBIAN_GRAPHICS_FBSERV_PAGEDATA -request that fbserv writable data is paged.
	SYMBIAN_GRAPHICS_FBSERV_UNPAGEDDATA -request that fbserv writable data is unpaged.
	SYMBIAN_GRAPHICS_FBSERV_PAGE_BITMAP_DATA_ONLY -request that only bitmap data is paged.
	SYMBIAN_GRAPHICS_FBSERV_PAGE_BITMAP_DATA_AND_SHARED_HEAP_ONLY -request that only bitmap data and shared heap are paged.
@internalComponent
*/
enum TFbsWritableDataPagingMode
	{
	EFbsWdpDefault=0x00, //No change to the rom-build writable data paging configuration (nothing was specified).
	EFbsWdpPagedData=0x01, //SYMBIAN_GRAPHICS_FBSERV_PAGEDATA was specified.
	EFbsWdpUnpagedData=0x02, //SYMBIAN_GRAPHICS_FBSERV_UNPAGEDDATA was specified.
	EFbsWdpPageBitmapDataChunkOnly=0x03, //SYMBIAN_GRAPHICS_FBSERV_PAGE_BITMAP_DATA_ONLY was specified.
	EFbsWdpPageBitmapDataAndSharedHeapChunksOnly=0x04, //SYMBIAN_GRAPHICS_FBSERV_PAGE_BITMAP_DATA_AND_SHARED_HEAP_ONLY was specified.
	};


/*
Structure used to pass parameters from FBS client to FBS server.
Used when opening/closing an outline iterator.
@internalTechnology
*/
class TFBSGlyphOutlineParam 
    {
public:
    TInt iHandle;
    TInt iCount;
    TBool iHinted;
    };

/*
Structure used to pass font table/glyph outlines from FBS to FBS client.
Used when opening an font table or an outline iterator.
@internalTechnology
*/
class TOffsetLen 
    {
public:
    TInt iOffset;
    TInt iLen;
    };

/**
Maximum number of glyphs to be sent to server/received from client at a time, 
when retrieval of glyphs is necessary for implementation of RFbsGlyphDataIterator.
*/
const TInt KMaxGlyphBatchSize = 8;

/**
Maximum number of TOpenFontCharMetrics structures to be sent to server/received
from client at a time, when retrieval of glyph metrics is necessary for
implementation of RFbsGlyphMetricsArray.
*/
const TInt KMaxMetricsBatchSize = 16;

/**
Used by RFbsGlyphDataIterator for client/server communication of glyph info.
Contains all the data necessary to retrieve a glyph from server and recreate
glyph in client process.
@internalComponent 
 */
class TGlyphImageInfo
    {
public:
    inline TGlyphImageInfo() : iImageId(KSgNullDrawableId), iPosX(0), iPosY(0) {}
public:
    TSgDrawableId iImageId;
    TInt16 iPosX;
    TInt16 iPosY;
    TOpenFontCharMetrics iMetrics;
    };

/**
Used by CGlyphDataIteratorImpl. It is a container to group the 
metadata and the image data of an individual glyph recevied from the
server, all together. A collection of these is stored in the font,
received from the server in batches.
@internalComponent 
*/
struct TGlyphBatchItem
    {
    TSglQueLink iLink;
    RSgImage iImage;
    TGlyphImageInfo iInfo;
    };

/**
Implementor class of RFbsGlyphDataIterator. This class contains all
state information and contains much of the implementation of the
behaviour.
@internalComponent 
 */
NONSHARABLE_CLASS(CGlyphDataIteratorImpl) : public CBase
    {
public:
    CGlyphDataIteratorImpl(TInt aFbsFontHandle, const TUint* aGlyphCodes, TInt aCount);
    ~CGlyphDataIteratorImpl();
    TInt Initialise();
    TInt Next();
    void UpdateGlyphRect();
    TInt UpdateGlyphBatch(TInt aIndex);
    
public:    
    TSglQue<TGlyphBatchItem> iGlyphBatch;   // Linked-list of the current batch of received glyphs.
    const TUint* iGlyphDataIterCodes;       // An array of glyph codes
    TInt  iGlyphDataIterCodeCount;          // The number of glyph codes in the array
    TInt  iGlyphDataIterCodeIndex;          // The index of the current glyph code in the array
    TRect iGlyphDataIterRect;               // The current glyph rectangle.
    TInt  iFbsFontHandle;                   // The Font Handle the iterator was opened with  
    RFbsSession* iFbs;
    };

#endif