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

/**

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

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

	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)

			{