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

//

#include <fntstore.h>

#include <bitmap.h>

#include <openfont.h>

#include <graphics/fbsoogmmessage.h>

#include "FbsMessage.H"

#include "SERVER.H"

#include "BackGroundCompression.h"

#include <shapeinfo.h>

#include <graphics/shaperparams.h>

#include "glyphatlas.h"

#include "OstTraceDefinitions.h"

#include "fbstrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "FBSCLITraces.h"

#endif

/**

Bitwise mask that sets the MSB to indicate to a font rasterizer

that a code is a glyphcode and not a character code

*/

const TUint32 KTreatAsGlyphCodeFlag = 1UL << 31;

/** Helper function for converting a pointer to an offset from the passed

heap base. Use OffsetToPointer() to convert the returned offset back to a

useable pointer.

@param aAny A pointer to be converted to an offset.

@param aHeapBase The heap base of the current process.

@return An offset representing the passed pointer that can be converted

back to a pointer using the function OffsetToPointer(). 

@see OffsetToPointer()

 */

LOCAL_C TInt PointerToOffset(const TAny* aAny, TInt aHeapBase)

	{

	TInt offset = 0;

	if (aAny && aHeapBase)

		{

		offset = reinterpret_cast<TInt>(aAny) - aHeapBase;

		}

	return offset;

	}

/** Helper function for converting an offset (that was calculated using

PointerToOffset()) back to a pointer relative to the passed heap base.

@param aOffset The offset to be converted to a pointer.

@param aHeapBase The heap base of the current process.

@return A pointer relative to the passed heap base.

@see PointerToOffset()

 */

LOCAL_C TAny* OffsetToPointer(TInt aOffset, TInt aHeapBase)

	{

	if (aOffset && aHeapBase)

		{

		return reinterpret_cast<TAny*>(aOffset + aHeapBase);

		}

	return NULL;

	}

CFbClient::CFbClient(RHeap* aHeap):

	CSession2(),

	iHeap(aHeap)

#ifdef _DEBUG

	,iOwnHeapFailNumber(-1),

	iSharedHeapFailNumber(-1)

#endif	

	{

	}

CFbClient* CFbClient::NewL(RHeap* aHeap)

	{

	CFbClient* self = new (ELeave) CFbClient(aHeap);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self;

	return self;

	}

/**

Two-phase constructor.

@leave KErrNoMemory if TOpenFontGlyphData construction failed.

*/

void CFbClient::ConstructL()

	{

	iOpenFontGlyphData = TOpenFontGlyphData::New(iHeap, 4 * 1024);

	if (!iOpenFontGlyphData)

		{

		User::Leave(KErrNoMemory);

		}

	}

CFbClient::~CFbClient()

	{

	/*

	Don't call any CFontStore functions if CFbClient::NewL has left, or if FBSERV has already deleted the

	font store, which happens in test programs like TFBS when FBSERV is closed before the client(s).

	*/

	CFontStore* font_store = NULL;

	CFbTop* fbTop = TopLevelStore();

	if (fbTop)

		{

		font_store = fbTop->FontStore();

		}

	if (font_store)

		{

		font_store->DeleteSessionCache(iSessionHandle);

		font_store->CleanupCacheOnFbsSessionTermination(iSessionHandle);

		// If the font store doesn't exist, neither will the shared heap owned by FBSERV.

		iHeap->Free(iOpenFontGlyphData);

		}

	// delete fonts held by the client

	delete iIx;

	// delete font files held by the client

	if (iFontFileIndex)

		{

		TInt count = iFontFileIndex->Count();

		for (TInt index = 0;index < count; index++)

			{

			if (font_store)

				{

				font_store->RemoveFile(iFontFileIndex->At(0).iUid);

				}

			iFontFileIndex->Delete(0);

			}

		delete iFontFileIndex;

		}

	// Close the buffer used to hold the text that needs shaping.

	iTextToShape.Close();

	for (TInt i = iGlyphImagesInTransit.Count() - 1; i >= 0; --i)

		{

		iGlyphImagesInTransit[i].Close();

		}

	iGlyphImagesInTransit.Close();

	}

void CFbClient::Init(TUint aConnectionHandle)

	{

	iConnectionHandle=aConnectionHandle;

	}

void CFbClient::CreateL()

	{

	iIx=CObjectIx::NewL();

	iFontFileIndex=new(ELeave) CArrayFixFlat<TFontFileIndex>(1);

	}

CFontBitmapServer* CFbClient::FontBitmapServer()

	{

	return((CFontBitmapServer*)Server());

	}

CFbTop* CFbClient::TopLevelStore()

	{

	CFontBitmapServer* server = FontBitmapServer();

	if (server)

		{

		return server->TopLevelStore();

		}

	else

		{

		return NULL;

		}

	}

void CFbClient::CopyFontInfo(CFontObject* aFontObjPtr,TInt aHandle,TFontInfo& aFontInfo)

	{

	CBitmapFont* font=aFontObjPtr->iAddressPointer;

	aFontInfo.iHandle = aHandle;

	aFontInfo.iServerHandle=(TInt)aFontObjPtr;

	aFontInfo.iAddressOffset=TInt(font)-TopLevelStore()->HeapBase();

	}

void CFbClient::ServiceL(const RMessage2& aMessage)

	{

#ifdef _DEBUG

	TBool resetOwnHeap=EFalse;

	TBool resetSharedHeap=EFalse;

	//the memory tests have been mostly written to have start and end memory

	//function calls (or macros) at the start of this function call (ServiceL)

	//and the matching call (or macro) is at the end of this function.

	if (iOwnHeapFailNumber!=-1)

		{

		//if this not -1 then know to set the heap to fail on

		//the given number of allocations

		resetOwnHeap=ETrue;

		__UHEAP_SETFAIL(RHeap::EDeterministic,iOwnHeapFailNumber);

		}

	if (iSharedHeapFailNumber!=-1)

		{

		resetSharedHeap=ETrue;

		__RHEAP_SETFAIL (iHeap, RHeap::EDeterministic,iSharedHeapFailNumber);

		}	

	if (iOwnHeapCheck)

		{

		__UHEAP_MARK;

		}					

	if (iHeapCheck)

		{

		__RHEAP_MARK(iHeap);

		}		

#endif		

	//Call close on RSgImage handles being used to share glyph data with clients.

	//The glyph images are held open to prevent the GlyphAtlas from closing them

	//before a client can use them.

	for (TInt i = iGlyphImagesInTransit.Count() - 1; i >= 0; --i)

		{

		iGlyphImagesInTransit[i].Close();

		iGlyphImagesInTransit.Remove(i);

		}

	switch(aMessage.Function())

		{

// client messages

	case EFbsMessInit:

		Init(FontBitmapServer()->Init());

		iSessionHandle = (TInt)this;

		aMessage.Complete(iSessionHandle);

#ifdef _DEBUG

		iRet=KErrNone;

#endif		

		break;

	case EFbsMessClose:

		{

		TInt localhandle=aMessage.Int0();

		if(!iIx->At(localhandle))

			{

			aMessage.Panic(KFBSERVPanicCategory,KErrNotFound);

			break;

			}

		iIx->Remove(localhandle);

		iResourceCount--;

		aMessage.Complete(KErrNone);

		FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_SERVICEL_INFO, "# Server resource destroyed; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)

#ifdef _DEBUG

		iRet=KErrNone;

#endif				

		break;

		}

	case EFbsMessResourceCount:

		aMessage.Complete(iResourceCount);

#ifdef _DEBUG

		iRet=iResourceCount;

#endif			

		break;

// server messages

	case EFbsMessShutdown:

	case EFbsMessNumTypefaces:

	case EFbsMessTypefaceSupport:

	case EFbsMessFontHeightInTwips:

	case EFbsMessFontHeightInPixels:

	case EFbsMessSetPixelHeight:

	case EFbsMessDefaultAllocFail:

	case EFbsMessDefaultMark:

	case EFbsMessDefaultMarkEnd:

	case EFbsMessUserAllocFail:

	case EFbsMessUserMark:

	case EFbsMessUserMarkEnd:

	case EFbsMessHeapCheck:

	case EFbsMessSetDefaultGlyphBitmapType:

	case EFbsMessGetDefaultGlyphBitmapType:

	case EFbsMessFontNameAlias:

	case EFbsMessGetHeapSizes:

	case EFbsMessDefaultLanguageForMetrics:

	case EFbsCompress:

	case EFbsMessFetchLinkedTypeface:

	case EFbsMessRegisterLinkedTypeface:

	case EFbsMessUpdateLinkedTypeface:

#ifdef _DEBUG

		FontBitmapServer()->ProcMessage(aMessage,iSessionHandle,iRet);

#else

		FontBitmapServer()->ProcMessage(aMessage,iSessionHandle);

#endif			

		break;

// font messages

	case EFbsMessFontDuplicate:

	case EFbsMessGetNearestFontToDesignHeightInTwips:

	case EFbsMessGetNearestFontToDesignHeightInPixels:

	case EFbsMessGetNearestFontToMaxHeightInTwips:

	case EFbsMessGetNearestFontToMaxHeightInPixels:

	case EFbsMessGetFontById:

	case EFbsMessInstallFontStoreFile:

	case EFbsMessAddFontStoreFile:

	case EFbsMessRemoveFontStoreFile:

	case EFbsMessRasterize:

	case EFbsMessFaceAttrib:

	case EFbsMessHasCharacter:

	case EFbsMessShapeText:

	case EFbsMessShapeDelete:

	case EFbsMessSetTwipsHeight:

	case EFbsMessGetTwipsHeight:

	case EFbsSetSystemDefaultTypefaceName:

	case EFbsMessGetFontTable:

	case EFbsMessReleaseFontTable:

	case EFbsMessGetGlyphOutline:

	case EFbsMessReleaseGlyphOutline: 

#if (_DEBUG)

	case EFbsMessSetDuplicateFail:

#endif

	case EFbsMessGetGlyphs:

	case EFbsMessGetGlyphMetrics:

		ProcFontMessage(aMessage);

		break;

// bitmap messages

	case EFbsMessBitmapCreate:

	case EFbsMessBitmapResize:

	case EFbsMessBitmapDuplicate:

	case EFbsMessBitmapLoad:

	case EFbsMessBitmapCompress:

	case EFbsMessBitmapBgCompress:

	case EFbsMessBitmapClean:

	case EFbsGetAllBitmapHandles:

	case EFbsMessBitmapLoadFast:

	case EFbsMessBitmapNotifyDirty:

	case EFbsMessBitmapCancelNotifyDirty:

		ProcBitmapMessage(aMessage);

		break;

//Memory messages		

	case EFbsMessSetHeapFail:

	case EFbsMessHeapCount:

	case EFbsMessSetHeapReset:

	case EFbsMessSetHeapCheck:

	case EFbsMessHeap:

#ifdef _DEBUG	

		ProcMemMessage(aMessage);

#else

		aMessage.Complete(KErrNone);

#endif	

		break;

// Glyph Atlas messages (debug-only)

	case EFbsMessAtlasFontCount:

	case EFbsMessAtlasGlyphCount:

#ifdef _DEBUG

		ProcAtlasMessage(aMessage);

#else

		aMessage.Complete(KErrNotSupported);

#endif

		break;

    case EFbsMessOogmNotification:

        aMessage.Complete( HandleMesgOogmStatus( aMessage ) );

        break;

    case EFbsMessGetGlyphCacheMetrics:

        HandleMesgGlyphCacheMetrics( aMessage );

        break;

//No-op message

	case EFbsMessNoOp:

#ifdef _DEBUG

		iRet = KErrNone;

#endif

		aMessage.Complete(KErrNone);

		break;

	default:

		aMessage.Panic(KFBSERVPanicCategory,KErrArgument);

		break;

		}

#ifdef _DEBUG

	//do not want a memory panic if the return code is OK

	//__UHEAP_MARKEND does this

	if (iOwnHeapCheck)

		{

		TUint32 badCell=User::Heap().__DbgMarkEnd(0);

		if (iRet<0)

			{

			//if the function call was a success, there may have been valid memory allocations,

			//so only panic if the call failed, and the memory is not the same before and after the

			//function call

			__ASSERT_DEBUG (badCell==NULL,User::Panic(KFBSERVPanicCategory, KErrGeneral));

			}

		}					

	if (iHeapCheck)

		{

		TUint32 badCell2=0;

		badCell2= __RHEAP_MARKEND(iHeap);

		//the above function call does not panic if there is a failure, this is

		//only for the user heap

		if (iRet<0)

			{

			__ASSERT_DEBUG (badCell2==NULL,User::Panic(KFBSERVPanicCategory, KErrGeneral));

			}

		}

	//change the state of the memory check?	

	if (iOwnHeapCheckFlip)

		{

		//change the state of the memory testing

		//if the mark was set still need to have a mark end

		iOwnHeapCheckFlip=EFalse;

		iOwnHeapCheck=!iOwnHeapCheck;

		}

	if (iHeapCheckFlip)

		{

		iHeapCheckFlip=EFalse;

		iHeapCheck=!iHeapCheck;

		}

	if (resetOwnHeap)

		{

		//previously set failures, reset

		__UHEAP_RESET;

		}

	if (resetSharedHeap)

		{		

		__RHEAP_RESET (iHeap);

		}		

#endif		

	}

/** Handler for EFbsMessFontDuplicate message

 @param aMessage input parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return KErrNone if successful, otherwise a system wide error code

 */

TInt CFbClient::HandleMesgFontDuplicate(const RMessage2& aMessage, TBool& aPanicRequired)

	{

#if _DEBUG

	if (iFontDuplicateToFail)

		{

		return KErrNoMemory; //return with this error since this error is possible

		}

#endif

	CFontObject* fontptr = (CFontObject*) aMessage.Int0();

	if(!TopLevelStore()->ValidFontHandle((TInt)fontptr))

		{

		return KErrUnknown;

		}

	TPckgBuf<TFontInfo> fontinfo;

	TInt localhandle = 0;

	TInt ret = fontptr->Open();

	if (ret != KErrNone)

		{

		return ret;

		}

	TRAP(ret, localhandle=iIx->AddL(fontptr));

	if (ret != KErrNone)

		{

		fontptr->Close();

		return ret;

		}

	CopyFontInfo(fontptr,localhandle,fontinfo());

	fontptr->iHeightInTwips = ((fontptr->iAddressPointer->HeightInPixels() * fontptr->iFontStore->iKPixelHeightInTwips) + 667) / 1000;

	ret = aMessage.Write(1, fontinfo);

	if(ret != KErrNone)

		{

		iIx->Remove(localhandle);

		aPanicRequired = ETrue;

		return ret;

		}

	// success

	iResourceCount++;

    FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_HANDLEMESGFONTDUPLICATE_INFO, "# Server font duplicated; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)

	return KErrNone;

	}

/** Handler for EFbsMessGetNearestFontToDesignHeightInTwips, EFbsMessGetNearestFontToDesignHeightInPixels, 

 EFbsMessGetNearestFontToMaxHeightInTwips or EFbsMessGetNearestFontToMaxHeightInPixels messages

 @param aMessage input and output parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return KErrNone if successful, otherwise a system wide error code

 */

TInt CFbClient::HandleMesgGetNearestFont(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFontObject* fontptr = NULL;

	TPckgBuf<TFontSpec> pckgFontSpec;

	TInt pckgMaxHeight;

	TPckgBuf<TSizeInfo> info;

	const TFbsMessage fbsMessage = static_cast<TFbsMessage>(aMessage.Function());

	TInt ret = aMessage.Read(0, pckgFontSpec);

	TFontSpec& fontSpec = pckgFontSpec();

	if (ret == KErrNone )

		{

		TInt length = fontSpec.iTypeface.iName.Length();

		if((length < 0) || (length > TOpenFontFaceAttribBase::ENameLength))

			{

			aPanicRequired = ETrue;

			return KErrArgument;

			}	

		ret = aMessage.Read(2, info);

		if (ret == KErrNone)

			{

			pckgMaxHeight = info().iMaxHeight;

			TopLevelStore()->FontStore()->iKPixelHeightInTwips=info().iDevSize.iHeight;

			TopLevelStore()->FontStore()->iKPixelWidthInTwips=info().iDevSize.iWidth;

			}

		}

	if (KErrNone != ret)

		{

		aPanicRequired = ETrue;

		return ret;

		}

	if ( (EFbsMessGetNearestFontToMaxHeightInTwips == fbsMessage) || (EFbsMessGetNearestFontToMaxHeightInPixels == fbsMessage) )

		{

		ret = TopLevelStore()->GetNearestFont(fontptr, fbsMessage, fontSpec, pckgMaxHeight);

		}

	else

		{

		ret = TopLevelStore()->GetNearestFont(fontptr, fbsMessage, fontSpec);

		}

	if (ret == KErrNone)

		{ // package up the result

		ret = CopyFontInfoIntoReturnMessage(aMessage, aPanicRequired, fontptr, 1);

		}

	return ret;

	}

 /** package up the font that was found - includes cleanup handling in case of error

 @param aMessage input and output parameters

 @param aPanicRequired flag that is set if a client panic is required

 @param aFontObj the object that is to be returned

 @param aWritePosition the slot position in the message pointing to the receiving object

 @return KErrNone if successful, otherwise a system wide error code

 */

TInt CFbClient::CopyFontInfoIntoReturnMessage(const RMessage2& aMessage, TBool& aPanicRequired, CFontObject* aFontObj, TInt aWritePosition)

	{

	TInt localhandle = 0;

	TRAPD(ret, localhandle = iIx->AddL(aFontObj));

	if (KErrNone != ret)

		{

		aFontObj->Close();

		return ret;

		}

	TPckgBuf<TFontInfo> pckgFontInfo;

	CopyFontInfo(aFontObj, localhandle, pckgFontInfo());

	ret = aMessage.Write(aWritePosition, pckgFontInfo);

	if (KErrNone != ret)

		{

		iIx->Remove(localhandle);

		aPanicRequired = ETrue;

		return ret;

		}

	// success

	iResourceCount++;

	FBS_OST(OstTraceExt3( GRAPHICS_RESOURCE_MANAGEMENT_SEMANTICS, CFBCLIENT_COPYFONTINFOINTORETURNMESSAGE_INFO, "# Server font duplicated; iSSH=0x%08x; rc=%d; iH=0x%08x;", iSessionHandle, iResourceCount, localhandle);)

	return KErrNone;

	}

/** Handler for EFbsMessGetFontById message

 Works for Bitmap fonts only, see implementation in CFbTop::GetFontById() & CFontStore::GetFontById().

 @param aMessage input and output parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return KErrNone if successful, otherwise a system wide error code

 */

TInt CFbClient::HandleMesgGetFontById(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFontObject* fontptr = NULL;

	TPckgBuf<TAlgStyle> algstyle;

	TPckgBuf<TSize> size;

	TInt ret = aMessage.Read(1, algstyle);

	if (ret == KErrNone)

		{ // get font size

		ret = aMessage.Read(3, size);

		if (ret == KErrNone)

			{

			TopLevelStore()->FontStore()->iKPixelHeightInTwips = size().iHeight;

			TopLevelStore()->FontStore()->iKPixelWidthInTwips = size().iWidth;

			}

		}

	if (ret != KErrNone)

		{

		aPanicRequired = ETrue;

		return ret;

		}

	TUid fileid;

	fileid.iUid = aMessage.Int2();

	ret = TopLevelStore()->GetFontById(fontptr,fileid,algstyle());

	if (ret == KErrNone)

		{ // package up the result

		ret = CopyFontInfoIntoReturnMessage(aMessage, aPanicRequired, fontptr, 0);

		}

	return ret;

	}

/** Handler for EFbsMessInstallFontStoreFile or EFbsMessAddFontStoreFile messages

 @param aMessage input and output parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return KErrNone if successful, otherwise a system wide error code

 */

TInt CFbClient::HandleMesgAddOrInstallFontFile(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	TPckgBuf<TIntParcel> id;

	TInt length=aMessage.Int1();

	if(length < 0 || length * sizeof(TText) >= KMaxTInt/2)

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	TText* buffer=(TText*)User::Alloc(length*sizeof(TText));

	if(buffer==NULL)

		{

		return KErrNoMemory;

		}

	TPtr filename(buffer,length,length);

	TInt ret = aMessage.Read(0,filename);

	if(ret!=KErrNone)

		{

		User::Free(buffer);

		aPanicRequired = ETrue;

		return ret;

		}

	TRAP(ret, id().iInt = TopLevelStore()->FontStore()->AddFileL(filename).iUid);

	User::Free(buffer);

	if (ret != KErrNone)

		{

		return ret;

		}

	TUid uid;

	uid.iUid=id().iInt;

	if (aMessage.Function() == EFbsMessAddFontStoreFile)

		{

		TRAP(ret, AddFontFileIndexL(uid));

		if (ret!=KErrNone)

			{

			TopLevelStore()->FontStore()->RemoveFile(uid);

			return ret;

			}

		}

	ret = aMessage.Write(2,id);

	if (ret!=KErrNone)

		{

		RemoveFontFileIndex(uid);

		aPanicRequired = ETrue;

		}

	return ret;

	}

/** Handler for EFbsMessRemoveFontStoreFile message

 @param aMessage input parameters

 @return KErrNone if successful

 */

TInt CFbClient::HandleMesgRemoveFontFile(const RMessage2& aMessage)

	{

	TUid uid;

	uid.iUid=aMessage.Int0();

	RemoveFontFileIndex(uid);

	return KErrNone;

	}

/** Handler for EFbsMessRasterize message

 @param aMessage input parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return ETrue if successful, EFalse or any system-wide error code if not successful.

 */

TInt CFbClient::HandleMesgRasterize(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFbTop* fbtop = TopLevelStore();

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	CBitmapFont* bitmapFont = fontptr->iAddressPointer;

	const TUint charCode = aMessage.Int1();

	if ( (bitmapFont != NULL) && (bitmapFont->Rasterize(iSessionHandle, charCode, iOpenFontGlyphData)) )

		{

		// Convert all pointers to be passed back to the client to offsets from

		// the heap base so that they can be recreated client side relative to the

		// client's heap base

		TInt heapbase = fbtop->HeapBase();

		TPckgBuf<TRasterizeParams> params;

		params().iMetricsOffset = PointerToOffset(iOpenFontGlyphData->Metrics(), heapbase);

		params().iBitmapPointerOffset = PointerToOffset(iOpenFontGlyphData->BitmapPointer(), heapbase);;

		TInt err = aMessage.Write(2, params);

		if (KErrNone != err)

			{

			aPanicRequired = ETrue;

			return err;

			}

		return ETrue;

		}

	return EFalse;

	}

/** Handler for EFbsMessGetGlyphs message.

Reads a batch of up to KMaxGlyphBatchSize glyph codes, and on success returns

the corresponding TGlyphImageInfo objects.

 @param aMessage input parameters

 @param aPanicRequired flag that is set if a client panic is required

 @return KErrNone if successful, otherwise any system-wide error code.

 */

TInt CFbClient::HandleMesgGetGlyphs(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFbTop* fbtop = TopLevelStore();

	// Previously requested glyphs were closed in ServiceL()

	CGlyphAtlas* glyphAtlas = fbtop->GlyphAtlas();

	if (!glyphAtlas)

		{

		return KErrNotSupported;

		}

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrBadHandle;

		}

	TUint glyphCodes[KMaxGlyphBatchSize];

	TGlyphImageInfo glyphImageInfo[KMaxGlyphBatchSize];

	TPckg<TUint[KMaxGlyphBatchSize]> glyphBatchPckg(glyphCodes);

	TInt err = aMessage.Read(1, glyphBatchPckg);

	if (err != KErrNone)

		{

		aPanicRequired = ETrue;

		return err;

		}

	TInt glyphCodesCount = glyphBatchPckg.Length() / sizeof(TUint);

	if (glyphCodesCount > KMaxGlyphBatchSize)

		{

		aPanicRequired = ETrue;

		return KErrOverflow;

		}

	TInt glyphsProcessed = 0;

	CBitmapFont* font = fontptr->iAddressPointer;

	for (; (glyphsProcessed < glyphCodesCount); ++glyphsProcessed)

		{

		TUint32 glyphCode = glyphCodes[glyphsProcessed];

		err = glyphAtlas->GetGlyph(*font, glyphCode, glyphImageInfo[glyphsProcessed]);

		// Search for glyph in glyph atlas

		if (KErrNone != err)

			{

			const TUint8* bitmapData = NULL;

			TOpenFontCharMetrics metrics;

			// search for glyph in font glyph cache and session cache.

			if (!font->GetCharacterData(iSessionHandle, glyphCode | KTreatAsGlyphCodeFlag, metrics, bitmapData))

				{

				// Rasterize the glyph

				if(!font->Rasterize(iSessionHandle, glyphCode | KTreatAsGlyphCodeFlag, iOpenFontGlyphData))

					{

					err = KErrNoMemory;

					break;

					}

				metrics = *(iOpenFontGlyphData->Metrics());

				bitmapData = iOpenFontGlyphData->BitmapPointer();

				}

			CGlyphAtlas::TAddGlyphArgs args(bitmapData, glyphCode, metrics);

			err = glyphAtlas->AddGlyph(*font, args, glyphImageInfo[glyphsProcessed]);

			}

		if ((err == KErrNone) && (glyphImageInfo[glyphsProcessed].iImageId != KSgNullDrawableId))

			{

			// To prevent other threads closing the glyph image in the glyph atlas 

			// before client has had chance to open the drawable id, open a local

			// handle to the glyph image for the session, which will be closed either

			// next time a request is made or when EFbsMessCloseGlyphs is handled.

			RSgImage glyphImage;

			err = glyphImage.Open(glyphImageInfo[glyphsProcessed].iImageId);

			if (err == KErrNone)

				{

				err = iGlyphImagesInTransit.Append(glyphImage);

				}

			}

		// If an error occurred during this iteration, abort now before the glyphsProcessed

		// counter is incremented, which would give one too many processed glyphs.

		if (KErrNone != err)

			{

			break;

			}

		}

	// Even if there was an error, if at least one glyph was processed successfully

	// send that back to the client, and reset the error code.

	if (glyphsProcessed > 0)

		{

		TPckg<TGlyphImageInfo[KMaxGlyphBatchSize]> glyphImageInfoPckg(glyphImageInfo);

		glyphImageInfoPckg.SetLength(glyphsProcessed * sizeof(TGlyphImageInfo));

		err = aMessage.Write(2, glyphImageInfoPckg);

		if (err != KErrNone)

			{

			aPanicRequired = ETrue;

			return err;

			}

		}

	else

		{

		// No glyphs being returned, so an error code must be returned.

		__ASSERT_DEBUG(err != KErrNone, User::Panic(KFBSERVPanicCategory, err));

		}

	return err;

	}

/**

Handler for EFbsMessGetGlyphMetrics message.

Reads an array of glyph codes, and returns the offset from the heap base for the 

corresponding metrics object.

@pre The glyph codes have already been searched client-side in the font glyph

	cache and the session cache.

@param aMessage input parameters

@param aPanicRequired flag that is set if a client panic is required

@return KErrNone if successful, otherwise any system-wide error code.

 */

TInt CFbClient::HandleMesgGetGlyphMetrics(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFbTop* fbtop = TopLevelStore();

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrBadHandle;

		}

	TInt err = KErrNone;

	TUint glyphCodes[KMaxMetricsBatchSize];

	TPckg<TUint[KMaxMetricsBatchSize]> glyphBatchPckg(glyphCodes);

	err = aMessage.Read(1, glyphBatchPckg);

	if (err != KErrNone)

		{

		aPanicRequired = ETrue;

		return err;

		}

	TInt numGlyphCodes = glyphBatchPckg.Length() / sizeof(TUint);	

	if (numGlyphCodes > KMaxMetricsBatchSize)

		{

		aPanicRequired = ETrue;

		return KErrOverflow;

		}

	CBitmapFont* font = fontptr->iAddressPointer;

	const TInt heapbase = fbtop->HeapBase();

	TInt glyphProcessed;

	TInt glyphMetricsOffsets[KMaxMetricsBatchSize];

	for (glyphProcessed = 0; (glyphProcessed < numGlyphCodes) && (err == KErrNone); ++glyphProcessed)

		{

		if (font->Rasterize(iSessionHandle, glyphCodes[glyphProcessed] | KTreatAsGlyphCodeFlag, iOpenFontGlyphData))

			{

			// Convert all pointers to be passed back to the client to offsets from

			// the heap base so that they can be recreated client side relative to the

			// client's heap base

			glyphMetricsOffsets[glyphProcessed] = PointerToOffset(iOpenFontGlyphData->Metrics(), heapbase);

			}

		else

			{

			err = KErrNoMemory;

			}

		}

	if (err == KErrNone)

		{

		TPckg<TInt[KMaxMetricsBatchSize]> glyphMetricsOffsetsPckg(glyphMetricsOffsets);

		glyphMetricsOffsetsPckg.SetLength(glyphProcessed * sizeof(TInt));

		err = aMessage.Write(2, glyphMetricsOffsetsPckg);

		if (err != KErrNone)

			{

			aPanicRequired = ETrue;

			}

		}	

	return err;

	}

/** Handler for EFbsMessFaceAttrib message

 @param aMessage Input and output parameters

 @param aPanicRequired Flag that is set to ETrue if a client panic is required

 @return ETrue if successful, EFalse or any system-wide error code if not successful.

	 An error code is only returned if aPanicRequired is set to ETrue.

 */

TInt CFbClient::HandleMesgFaceAttrib(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), TopLevelStore()->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	CBitmapFont* bitmapFont = fontptr->iAddressPointer;

	TInt ret = EFalse;

	TPckgBuf<TOpenFontFaceAttrib> package;

	if ( (bitmapFont != NULL) && (bitmapFont->GetFaceAttrib(package())) )

		{

		ret = aMessage.Write(1,package);

		if (ret == KErrNone)

			{

			ret = ETrue;

			}

		else

			{

			aPanicRequired = ETrue;

			}

		}

	return ret;

	}

/** Handler for EFbsMessHasCharacter message

 @param aMessage Input parameters

 @param aPanicRequired Flag that is set to ETrue if a client panic is required

 @return ETrue if the font has the character, EFalse if the font does not have

  the character, or any system-wide error code if not successful. An error code

  is only returned if aPanicRequired is set to ETrue.

 */

TInt CFbClient::HandleMesgHasCharacter(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), TopLevelStore()->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	CBitmapFont* bitmapFont = fontptr->iAddressPointer;

	TInt ret = 0;

	TRAPD(error, ret = bitmapFont->HasCharacterL(aMessage.Int1()));

	if (error != KErrNone)

		{

		return EFalse;

		}

	return ret;

	}

/** Handler for EFbsMessShapeText message

 @param aMessage Input and output parameters

 @param aPanicRequired Flag that is set to ETrue if a client panic is required

 @return An offset from the heap base where the pointer to the shape is located

	if successful, otherwise 0 or any system-wide error code. An error code is

	only returned if aPanicRequired is set to ETrue.

 */

TInt CFbClient::HandleMesgShapeText(const RMessage2& aMessage, TBool& aPanicRequired)

	{

	TInt error = KErrNone;

	TShapeHeader* shape = 0;

	if (aMessage.GetDesLength(2) != sizeof(TShapeMessageParameters))

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	CFbTop* fbtop = TopLevelStore();

	CFontObject* fontptr = static_cast<CFontObject*>(iIx->At(aMessage.Int0(), fbtop->FontConUniqueID()));

	if(!fontptr)

		{

		aPanicRequired = ETrue;

		return KErrArgument;

		}

	TInt inputTextLength = aMessage.GetDesLength(1);

	if (inputTextLength < 0)

		{

		error = inputTextLength;

		aPanicRequired = ETrue;

		return error;

		}

	else