/*

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

* FTRAST.CPP

* Wrapper code to connect FreeType with the EPOC rasterizer framework.

* This version uses FreeType 2.2.1

* Secure Rasterizer Plugin. The rasterizer is now implemented as 

* an ECOM Plugin. Secure FBServ uses ECOM APIs provided to load the 

* plugin.

*

*/

#include <e32uid.h>

#include <f32file.h>

#include <charconv.h>

#include <sys/reent.h>

#include <openfont.h>

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_GLYPH_H

#include FT_INTERNAL_TRUETYPE_TYPES_H

#include <ftsnames.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <gdi.h>

#include <e32hashtab.h>

#include <graphics/openfontrasterizer.h>

#include <graphics/gdi/glyphsample.h>

#include <graphics/openfontconstants.h>

static const TInt KOneIn16Dot16FixedPointFormat = 65536;

class CFreeTypeContext;

class CFreeTypeRasterizer : public COpenFontRasterizer

	{

public:

	static COpenFontRasterizer* NewL();

	virtual ~CFreeTypeRasterizer();

	// COpenFontRasterizer implementation

	COpenFontFile* NewFontFileL(TInt aUid, const TDesC& aFileName, RFs& aFileSession);

private:

	CFreeTypeRasterizer();

private:

	CFreeTypeContext* iContext;

	};

NONSHARABLE_CLASS(CFaceListItem) : public CBase

	{

	friend class CFaceList;

public:

	virtual ~CFaceListItem();

	static CFaceListItem* NewL(CFreeTypeContext* aContext, const TText8* aFileName, TInt aFaceIndex);

	void SetFaceNamesL(TOpenFontFaceAttrib& aAttrib) const;

	void GetBiggestGlyphsFromSampleL(

		TInt aScript, TInt& aUnicodeAscender, TInt& aUnicodeDescender) const;

	TBool LoadGlyphAndGetAscenderDescender(

		TUint32 aCode, TInt32& aAscender, TInt32& aDescender) const;

	TInt DeriveDesignHeightFromMaxHeightWithGlyphSampleL(

		TInt aMaxHeightInPixel, TInt aUnicodeAscender, TInt aUnicodeDescender) const;

	TInt DeriveDesignHeightFromMaxHeightWithBBoxL(TInt aMaxHeightInPixel) const;

	FT_Face Face(void) const;

private:

	static void GetDesiredLocalLanguageAndMask(TUint16& aDesiredLocalLanguage, TUint16& aLocalLanguageMask);

	static TInt CopyName(TInt aDestMaxLen, TUint16* aDest, const TUint8* aSrc);

	CFaceListItem();

	void ConstructL(CFreeTypeContext* aContext, const TText8* aFileName, TInt aFaceIndex);

	TInt GetFamilyAndStyleNames(TInt aDestMaxLen, TUint16* aDest, TInt& aFamilyNameLen) const;

	void SetTTFFaceNamesL(TOpenFontFaceAttrib& aAttrib) const;

private:

	CFaceListItem*	iNext;

	const TText8*	iFileName;	// owned by the CFreeTypeFontFile object

	TInt			iFaceIndex;

	FT_Face			iFace;

	};

NONSHARABLE_CLASS(CFaceList) : public CBase

	{

public:

	CFaceList();

	virtual ~CFaceList();

	CFaceListItem* LoadFaceL(CFreeTypeContext* aContext, const TText8* aFileName, TInt aFaceIndex);

	void DeleteFace(const TText8* aFileName, TInt aFaceIndex);

private:

	static TInt MemoryUsed(void);

	void DeleteLastFace(void);

private:

	/*

	The memory threshold is not an absolute limit because we must allow

	at least one typeface to be loaded, but if it is exceeded typefaces

	will be unloaded until just one is left (the one being used) or until

	the memory available no longer exceeds the threshold.

	*/

	enum

		{

		EMemoryThreshold = 1024 * 1024

		};

	CFaceListItem* iFirstItem;

	};

NONSHARABLE_CLASS(CFreeTypeContext) : public COpenFontRasterizerContext

	{

public:

	static CFreeTypeContext* NewL();

	virtual ~CFreeTypeContext();

	void TranslateMonochromeGlyphBitmap (FT_GlyphSlot aGlyphSlot, TOpenFontGlyphData* aGlyphData);

	void TranslateAntiAliasedGlyphBitmap(FT_GlyphSlot aGlyphSlot, TOpenFontGlyphData* aGlyphData);

	FT_Library Library(void) const;

	CFaceListItem* LoadFaceL(const TText8* aFileName, TInt aFaceIndex);

	void DeleteFace(const TText8* aFileName, TInt aFaceIndex);

private:

	void ConstructL(void);

	void WriteMonoData(TUint8 aData, TInt aBitCount);

private:

	FT_Library iLibrary;

	CFaceList iFaceList;

	};

NONSHARABLE_CLASS(CFreeTypeFontFile) : public COpenFontFile

	{

public:

	static CFreeTypeFontFile* NewL(

		CFreeTypeContext* aContext, TInt aUid, const TDesC& aFileName, RFs& aFileSession);

	virtual ~CFreeTypeFontFile();

	CFaceListItem* LoadFaceL(TInt aFaceIndex);

	CFaceListItem* LoadFaceAndSetTransformL(TInt aFaceIndex,

		TInt aSizeInPixels, TInt32 aWidthFactor, TInt32 aSlantFactor);

	void RasterizeL(

		TInt aCode, TInt aFaceIndex, TInt aSizeinPixels, TInt32 aWidthFactor, 

		TInt32 aSlantFactor, TGlyphBitmapType aBitmapType, TOpenFontGlyphData* aGlyphData);

	void RasterizeGlyphL(

		TInt aCode, TInt aFaceIndex, TInt aSizeInPixels, TInt32 aWidthFactor,

		TInt32 aSlantFactor, TGlyphBitmapType aBitmapType, TOpenFontGlyphData* aGlyphData);

	// COpenFontFile implementation

	void GetNearestFontInPixelsL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

	void GetNearestFontToDesignHeightInPixelsL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

	void GetNearestFontToMaxHeightInPixelsL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight);

	TBool HasUnicodeCharacterL(TInt aFaceIndex, TInt aCode) const;

	TAny* GetTrueTypeTable(TInt& aError, TInt aFaceIndex, TUint32 aTag, TInt* aLength);

private:

	static void SetGlyphMetrics(FT_GlyphSlot aGlyphSlot, TOpenFontGlyphData* aGlyphData);

	void GetNearestFontInPixelsL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight);

	CFreeTypeFontFile(TInt aUid, const TDesC& aFileName);

	void ConstructL(CFreeTypeContext* aContext, const TDesC& aFileName, RFs& aFileSession);

	void CreateFilenameInUTF8L(const TDesC& aFileName, RFs& aFileSession);

	static TUint32 TagHash(const TUint32& aTag);

	static TBool TagId(const TUint32& aTag1, const TUint32& aTag2);

	void DoRasterizeGlyphL(TInt aCode, const CFaceListItem* aFace,

		TGlyphBitmapType aBitmapType, TOpenFontGlyphData* aGlyphData);

private:

	CFreeTypeContext* iContext;

	TText8* iFileName; // in null-terminated UTF8 so that it can be passed to fopen

	RHashMap<TUint32, TPtrC8> iTableStore;

	};

NONSHARABLE_CLASS(CFreeTypeFont) : public COpenFont, public MOpenFontShapingExtension, 

	{

public:

	static CFreeTypeFont* NewL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, CFreeTypeFontFile* aFontFile,

		TInt aFaceIndex, TInt aSizeInPixels, TInt32 aWidthFactor, TInt32 aSlantFactor,

		TGlyphBitmapType aBitmapType, TInt aMaxHeight, TInt aScript);

	// COpenFont implementation

	void RasterizeL(TInt aCode, TOpenFontGlyphData* aGlyphData);

private:

	CFreeTypeFont(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, CFreeTypeFontFile* aFontFile,

		TInt aFaceIndex, TInt32 aWidthFactor, TInt32 aSlantFactor, TGlyphBitmapType aBitmapType);

	void ConstructL(TInt aSizeInPixels, TInt aMaxHeight, TInt aScript);

	void ComputeMetrics(const FT_Face& aFace, TInt aSizeInPixels, TInt aUnicodeAscender, TInt aUnicodeDescender);

	void ComputeMaxWidth(const FT_Face& aFace);

	// Overload to access extended API

	void ExtendedInterface(TUid aUid, TAny*& aParam);

	// virtual functions from MOpenFontShapingExtension

	void RasterizeGlyphL(TInt aCode,TOpenFontGlyphData* aGlyphData);

	TInt GlyphIndex(TInt aUnicodeCharacter) const;

	TBool GlyphPointInHintedPixels(TInt aGlyphIndex, TInt aPointNumber,

		TReal& aX, TReal& aY) const;

	TBool GlyphPointInFontUnits(TInt aGlyphIndex, TInt aPointNumber,

		TInt& aX, TInt& aY) const;

	void GetExtensionFontMetrics(

		MOpenFontShapingExtension::TExtensionFontMetrics& aOut);

	// virtual functions from MOpenFontTrueTypeExtension

	TAny* GetTrueTypeTable(TInt& aError, TUint32 aTag, TInt* aLength);

	TInt  ReleaseTrueTypeTable(TAny* aTable);

	TBool HasTrueTypeTable(TUint32 aTag);

	inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;

	inline TAny* operator new(TUint aSize) __NO_THROW;

	inline void operator delete(void*, TAny*) __NO_THROW;

	inline void operator delete(void*) __NO_THROW;

private:

	TInt32 iWidthFactor;				// algorithmic width factor as a 16.16 fixed-point number

	TInt32 iSlantFactor;				// algorithmic slant factor as a 16.16 fixed-point number

	TGlyphBitmapType iBitmapType;

	};

#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER

#warning Using patented technology!

#endif

inline TAny* CFreeTypeFont::operator new(TUint aSize, TAny* aBase) __NO_THROW

	{ return CBase::operator new(aSize, aBase); }

inline TAny* CFreeTypeFont::operator new(TUint aSize) __NO_THROW

	{ return CBase::operator new(aSize); }

inline void CFreeTypeFont::operator delete(void*, TAny*) __NO_THROW {}

inline void CFreeTypeFont::operator delete(void* a) __NO_THROW

	{

	// We happen to know that the constructor of CFreeTypeFont

	// will always set iHeap correctly before any leave.

	// We would be less certain of this in standard C++ where

	// constructors (and even initializer lists) may throw exceptions.

	CFreeTypeFont* f = reinterpret_cast<CFreeTypeFont*>(a);

	f->iHeap->Free(a);

	}

TInt CFaceList::MemoryUsed()

	{

	TInt total;

	User::AllocSize(total);

	return total;

	}

CFreeTypeContext* CFreeTypeContext::NewL()

	{

	CFreeTypeContext* context = new(ELeave) CFreeTypeContext;

	CleanupStack::PushL(context);

	context->ConstructL();

	CleanupStack::Pop();

	return context;

	}

void CFreeTypeContext::ConstructL()

	{

	if (FT_Init_FreeType(&iLibrary))

		{

		iLibrary = NULL;

		User::Leave(KErrNoMemory);

		}

	}

CFreeTypeContext::~CFreeTypeContext()

	{

	FT_Done_FreeType(iLibrary);

	}

FT_Library CFreeTypeContext::Library() const

	{

	return iLibrary;

	}

CFaceListItem* CFreeTypeContext::LoadFaceL(const TText8* aFileName, TInt aFaceIndex)

	{

	return iFaceList.LoadFaceL(this, aFileName, aFaceIndex);

	}

void CFreeTypeContext::DeleteFace(const TText8* aFileName, TInt aFaceIndex)

	{

	iFaceList.DeleteFace(aFileName, aFaceIndex);

	}

COpenFontRasterizer* CFreeTypeRasterizer::NewL()

	{

	CFreeTypeRasterizer* r = new(ELeave) CFreeTypeRasterizer;

	CleanupStack::PushL(r);

	r->iContext = CFreeTypeContext::NewL();

	CleanupStack::Pop();

	return r;

	}

CFreeTypeRasterizer::CFreeTypeRasterizer()

	{

	}

CFreeTypeRasterizer::~CFreeTypeRasterizer()

	{

	delete iContext;

	CloseSTDLIB();

	}

COpenFontFile* CFreeTypeRasterizer::NewFontFileL(TInt aUid, const TDesC& aFileName, RFs& aFileSession)

	{

	if (4 < aFileName.Length())

		{

		// Allow TrueType fonts

		_LIT(KFntStoreTrueTypeExtension,".ttf");

		// Allow OpenType fonts

		_LIT(KFntStoreOpenTypeExtension,".otf");

		TPtrC16 extension = aFileName.Right(4);

		if (0 == extension.CompareF(KFntStoreTrueTypeExtension)

			|| 0 == extension.CompareF(KFntStoreOpenTypeExtension))

			return CFreeTypeFontFile::NewL(iContext, aUid, aFileName, aFileSession);

		}

	return NULL;

	}

// Exported proxy for instantiation method resolution

// Define the interface UIDs

const TImplementationProxy ImplementationTable[] = 

	{

	IMPLEMENTATION_PROXY_ENTRY(0x101f7f5e, CFreeTypeRasterizer::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}

CFaceListItem* CFreeTypeFontFile::LoadFaceL(TInt aFaceIndex)

	{

	return iContext->LoadFaceL(iFileName, aFaceIndex);

	}

CFaceListItem* CFreeTypeFontFile::LoadFaceAndSetTransformL(TInt aFaceIndex,

	TInt aSizeInPixels, TInt32 aWidthFactor, TInt32 aSlantFactor)

	{

	CFaceListItem* face = iContext->LoadFaceL(iFileName, aFaceIndex);

	if (FT_Set_Pixel_Sizes(face->Face(), aSizeInPixels, aSizeInPixels))

		{

		User::Leave(KErrGeneral);

		}

	if (aWidthFactor != 0 &&

		(aWidthFactor != KOneIn16Dot16FixedPointFormat || aSlantFactor != 0))

		{

		FT_Matrix matrix;

		matrix.xx = aWidthFactor;

		matrix.xy = aSlantFactor;

		matrix.yx = 0;

		matrix.yy = KOneIn16Dot16FixedPointFormat;

		FT_Set_Transform(face->Face(),&matrix,NULL);

		}

	else

		FT_Set_Transform(face->Face(),NULL,NULL);

	return face;

	}

CFreeTypeFontFile* CFreeTypeFontFile::NewL(CFreeTypeContext* aContext, TInt aUid, const TDesC& aFileName, RFs& aFileSession)

	{

	CFreeTypeFontFile* f = new(ELeave) CFreeTypeFontFile(aUid, aFileName);

	CleanupStack::PushL(f);

	f->ConstructL(aContext, aFileName, aFileSession);

	CleanupStack::Pop();

	return f;

	}

/** Forms a hash value from a TrueType-style tag.

@param aTag

	Each byte will contain a lower-case ASCII value (or possibly a number).

@return

	Hash value. Because we want to avoid collisions, we will move the bottom

	four bits of all four bytes into non-overlapping positions. */

TUint32 CFreeTypeFontFile::TagHash(const TUint32& aTag)

	{

	TUint32 t = aTag;

	// The most useful bits are in the bottom nybbles of each byte

	t ^= t >> 12 | t << 20;

	return t ^ (t << 15 | t >> 17);

	}

TBool CFreeTypeFontFile::TagId(const TUint32& aTag1, const TUint32& aTag2)

	{

	return aTag1 == aTag2;

	}

CFreeTypeFontFile::CFreeTypeFontFile(TInt aUid, const TDesC& aFileName):

	COpenFontFile(aUid, aFileName),

	iTableStore(THashFunction32<TUint32>(CFreeTypeFontFile::TagHash),

		TIdentityRelation<TUint32>(CFreeTypeFontFile::TagId))

	{

	}

CFreeTypeFontFile::~CFreeTypeFontFile()

	{

	const TInt faces = FaceCount();

	for (TInt i = 0; i < faces; i++)

		iContext->DeleteFace(iFileName, i);

	delete[] iFileName;

	THashMapIter<TUint32, TPtrC8> it(iTableStore);

	it.NextValue();

	while (it.CurrentValue())

		{

		delete it.CurrentValue()->Ptr();

		it.NextValue();

		}

	iTableStore.Close();

	}

void CFreeTypeFontFile::ConstructL(CFreeTypeContext* aContext, const TDesC& aFileName, RFs& aFileSession)

	{

	iContext = aContext;

	CreateFilenameInUTF8L(aFileName, aFileSession);

	// Get the filename as a fallback for the typeface name.

	TParse p;

	p.Set(aFileName, NULL, NULL);

	const TPtrC name = p.Name();

	// Load the properties of all the faces in the file.

	//

	// A file may contain one face (e.g. TTF - TrueType Font) or many (e.g. TTC - TrueType Collection).

	// The number is determined from a value stored in the properties of the first face.

	//

	for (TInt face_index = 0, faces = 1; face_index < faces; face_index++)

		{

		// Load the face.

		const CFaceListItem* face = iContext->LoadFaceL(iFileName, face_index);

		// If this is the first face, get the total number of faces.

		if (face_index == 0)

			{

			faces = face->Face()->num_faces;

			if (faces < 1)

				User::Leave(KErrGeneral);

			}

		// Set the face names to the filename as a fallback in case SetFaceNameL doesn't find appropriate names.

		TOpenFontFaceAttrib attrib;

		attrib.SetFullName(name);

		attrib.SetFamilyName(name);

		attrib.SetLocalFullName(name);

		attrib.SetLocalFamilyName(name);

		// Set the face names to those stored in the file if possible.

		face->SetFaceNamesL(attrib);

		// Set the face attributes exposed via FT_Face.

		attrib.SetBold(FT_STYLE_FLAG_BOLD & face->Face()->style_flags);

		attrib.SetItalic(FT_STYLE_FLAG_ITALIC & face->Face()->style_flags);

		attrib.SetMonoWidth(FT_FACE_FLAG_FIXED_WIDTH & face->Face()->face_flags);

		// Set attributes present in TrueType information but not exposed via FT_Face.

		if (FT_FACE_FLAG_SFNT & face->Face()->face_flags)

			{

			const TT_Face tt_face = (TT_Face) face->Face();

			attrib.SetMinSizeInPixels(tt_face->header.Lowest_Rec_PPEM);

			attrib.SetCoverage(tt_face->os2.ulUnicodeRange1,tt_face->os2.ulUnicodeRange2,

							   tt_face->os2.ulUnicodeRange3,tt_face->os2.ulUnicodeRange4);

			const TInt serif_style = tt_face->os2.panose[1];

			attrib.SetSerif((serif_style >= 2 && serif_style <= 10) || serif_style >= 14);

			}

		// Add the face to the array of faces owned by the file.

		AddFaceL(attrib);

		// Unload the face from the cache; loading a font file should not result in the face remaining in the face cache.

		iContext->DeleteFace(iFileName, face_index);

		}

	}

void CFreeTypeFontFile::CreateFilenameInUTF8L(const TDesC& aFileName, RFs& aFileSession)

	{

	CCnvCharacterSetConverter* converter = CCnvCharacterSetConverter::NewLC();

	if (CCnvCharacterSetConverter::EAvailable !=

		converter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUtf8,aFileSession))

		{

		User::Leave(KErrGeneral);

		}

	const TInt filename_length = aFileName.Length();

	TInt utf8_length = 0;

	for (TInt i = 0; i < filename_length; i++)

		{

		const TText c = aFileName[i];

		if (c < 0x80)

			utf8_length++;

		else if (c < 0x800)

			utf8_length += 2;

		else

			utf8_length += 3; // allow 3 bytes, even for parts of surrogate pairs, in case CHARCONV doesn't handle them

		}

	iFileName = new(ELeave) TText8[utf8_length + 1];

	TPtr8 q(iFileName, filename_length * 4);

	converter->ConvertFromUnicode(q, aFileName);

	iFileName[q.Length()] = 0;

	CleanupStack::PopAndDestroy(converter);

	}

#ifndef WORDS_BIGENDIAN

static void SwapWords(TUint16* aStart, TInt aCount)

	{

	TUint8* p = (TUint8*)aStart;

	while (aCount-- > 0)

		{

		const TUint8 temp = *p;

		*p = p[1];

		p[1] = temp;

		p += 2;

		}

	}

#endif