// Copyright (c) 1995-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 <fntstore.h>

#include <bitmap.h>

#include <openfont.h>

#include "fbsmessage.h"

#include "SERVER.H"

#include "BackGroundCompression.h"

#include <shapeinfo.h>

#include <graphics/shaperparams.h>

/** 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)

	{

	if (aAny && aHeapBase)

		{

		return (TInt)aAny - (TInt)aHeapBase;

		}

	return 0;

	}

/** 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(const TInt aOffset, TInt aHeapBase)

	{

	if (aOffset && aHeapBase)

		{

		return (TAny*)(aOffset + (TInt)aHeapBase);

		}

	return NULL;

	}

CFbClient::CFbClient(RHeap* aHeap):

	CSession2(),

	iConnectionHandle(0),

	iIx(NULL),

	iResourceCount(0),

	iHeap(aHeap)

#ifdef _DEBUG

	,iOwnHeapFailNumber(-1),

	iSharedHeapFailNumber(-1)

#endif	

	{

	}

CFbClient* CFbClient::NewL(RHeap* aHeap)

	{

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

	c->iOpenFontGlyphData = TOpenFontGlyphData::New(aHeap,4 * 1024);

	if (!c->iOpenFontGlyphData)

		{

		delete c;

		User::Leave(KErrNoMemory);

		}

	return c;

	}

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);

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

	if (font_store)

		iHeap->Free(iOpenFontGlyphData);

	// delete fonts hold by the client

	delete iIx;

	// delete font files hold 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 thats needs shaping.

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

	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);

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

#if (_DEBUG)

	case EFbsMessSetDuplicateFail:

#endif

		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;

	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> foninfo;

	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,foninfo());

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

	ret = aMessage.Write(1, foninfo);

	if(ret != KErrNone)

		{

		iIx->Remove(localhandle);

		aPanicRequired = ETrue;

		return ret;

		}

	// success

	iResourceCount++;

	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++;

	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);