/*

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

* A header for the open font system, which allows SymbianOS

* to use fonts of arbitrary types, including TrueType/OpenType

* and other outline font formats.

*

*/

#ifndef __OPENFONT_H__

#define __OPENFONT_H__

#include <e32base.h>

#include <gdi.h>

#include <ecom/ecom.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <linkedfonts.h>

#include <graphics/openfontconstants.h>

#include <graphics/openfontrasterizer.h>

#include <openfontlinkedtypefaceelementspec.h>

#include <graphics/openfontlinkedtypefacespecification.h>

#include <graphics/openfontlinkedtypefaceextension.h>

#endif

class CFont;

class COpenFontFile;

class COpenFontGlyph;

class COpenFontGlyphCache;

class COpenFontGlyphTreeEntry;

class COpenFontPositioner;

class COpenFontSessionCache;

class COpenFontSessionCacheList;

class RFs;

class TCharacterMetrics;

class TFontSpec;

class TOpenFontFaceAttrib;

class CFontStore;

class TOpenFontFileData;

class TShapeHeader;

class CBitmapFont;

class CShaperFactory;

class CShaper;

class TShapeHeader;

class TFontShapeFunctionParameters;

class TFontShapeDeleteFunctionParameters;

class RShapeInfo;

class TShapeMessageParameters;

class CRasterizerLinkedTypefaceSpecification;

class TLinkedTypefaceSpecificationArgs;

/**

Supplied to COpenFont::ExtendedInterface() to access the extended

API interface MOpenFontShapingExtension.

@see	COpenFont::ExtendedInterface()

@see	MOpenFontShapingExtension

@publishedAll

@released

*/

const TUid KUidOpenFontShapingExtension = {0x10274DB9};

/**

Supplied to COpenFont::ExtendedInterface() to access the extended

API interface MOpenFontTrueTypeExtension.

@see	COpenFont::ExtendedInterface()

@see	MOpenFontTrueTypeExtension

@publishedAll

@released

*/

const TUid KUidOpenFontTrueTypeExtension = {0x1027553E};

const TUid KUidOpenFontGlyphOutlineExtension = {0x102872CE};

/**

Supplied to CShaper::ExtendedInterface() to get the language and script

code with which the current shaper is instatsiated.

@see	CShaper::ExtendedInterface()

@publishedAll

@released

*/

const TUid KUidShaperGetScript = {0x20009966};

const TUid KUidShaperGetLang = {0x20009967};

/**

Font metrics.

@see	CFbsFont::GetFontMetrics()

@publishedAll

@released

*/

class TOpenFontMetrics

	{

public:

	inline TOpenFontMetrics();

	IMPORT_C TOpenFontMetrics(const CFont* aFont);

	inline TInt Size() const;

	inline TInt Ascent() const;

	inline TInt Descent() const;

	inline TInt MaxHeight() const;

	inline TInt MaxDepth() const;

	inline TInt MaxWidth() const;

	inline void SetSize(TInt aSize);

	inline void SetAscent(TInt aAscent);

	inline void SetDescent(TInt aDescent);

	inline void SetMaxHeight(TInt aMaxHeight);

	inline void SetMaxDepth(TInt aMaxDepth);

	inline void SetMaxWidth(TInt aMaxWidth);

	/** WARNING: Function for internal and partner use ONLY. Compatibility is not guaranteed in future releases.*/

	IMPORT_C void SetBaselineCorrection(TInt aBaselineCorrection);

	IMPORT_C TInt BaselineCorrection();

private:

	TInt16 iDesignHeight;	// size of the font ('pointsize' in pixels)

	TInt16 iAscent;			// typographic ascent

	TInt16 iDescent;		// typographic descent

	TInt16 iMaxHeight;		// maximum height of a character; may be greater than iAscent

	TInt16 iMaxDepth;		// maximum depth of a character; may be greater than iDescent

	TInt16 iMaxWidth;		// maximum width of a character

	TInt16 iBaselineCorrection;

	TInt16 iReserved;

	};

/**

Character metrics  includes more information than TCharacterMetrics.

Character metrics allow characters to be placed horizontally or vertically. 

The character metrics encapsulated by this class are: Height, Width, Horizontal 

Bearing X, Horizontal Bearing Y, Horizontal Advance, Vertical Bearing X, 

Vertical Bearing Y, and Vertical Advance. Their meanings are described in the 

associated setter and getter functions.

Note : 

Vertical drawing (in the sense of characters drawn with horizontal baselines, 

but in a vertical line) is not yet supported by Symbian OS.

@see	CFont::GetCharacterData()

@see	CFbsFont::GetCharacterData() 

@publishedAll

@released

*/

class TOpenFontCharMetrics

	{

public:

	enum TUninitialized { EUninitialized };

public:

	/** Default constructor initializes all members to 0. */

	inline TOpenFontCharMetrics();

	/** Constructor that does not initialize any members. */

	TOpenFontCharMetrics(TUninitialized) {}

	IMPORT_C TOpenFontCharMetrics(const TCharacterMetrics& aMetrics);

	IMPORT_C TBool GetTCharacterMetrics(TCharacterMetrics& aMetrics) const;

	inline TInt Width() const;

	inline TInt Height() const;

	inline TInt HorizBearingX() const;

	inline TInt HorizBearingY() const;

	inline TInt HorizAdvance() const;

	inline TInt VertBearingX() const;

	inline TInt VertBearingY() const;

	inline TInt VertAdvance() const;

	inline void GetHorizBounds(TRect& aBounds) const;

	inline void GetVertBounds(TRect& aBounds) const;

	inline void SetWidth(TInt aWidth);

	inline void SetHeight(TInt aHeight);

	inline void SetHorizBearingX(TInt aHorizBearingX);

	inline void SetHorizBearingY(TInt aHorizBearingY);

	inline void SetHorizAdvance(TInt aHorizAdvance);

	inline void SetVertBearingX(TInt aVertBearingX);

	inline void SetVertBearingY(TInt aVertBearingY);

	inline void SetVertAdvance(TInt aVertAdvance);

	IMPORT_C void  SetGlyphType(TGlyphBitmapType);

	IMPORT_C TGlyphBitmapType GlyphType() const;

private:

	TInt16 iWidth;			// width of the glyph

	TInt16 iHeight;			// height of the glyph

	TInt16 iHorizBearingX;	// x component of horizontal bearing

	TInt16 iHorizBearingY;	// y component of horizontal bearing

	TInt16 iHorizAdvance;	// horizontal advance

	TInt16 iVertBearingX;	// x component of vertical bearing

	TInt16 iVertBearingY;	// y component of vertical bearing

	TInt16 iVertAdvance;	// vertical advance

	TUint16  iGlyphBitmapType;// Glyph bitmap type; TGlyphBitmapType

	TInt16 iReserved;

	};

/**

Font glyph data.

Objects of this type are used by rasterizers to supply glyph data to font 

and bitmap server clients. Unless you are writing a rasterizer you will not 

need to use an object of this type.

The object cannot be constructed and destroyed by normal means. It resides 

on a specified heap. It is created by New() and deleted by RHeap::Free().

@see	COpenFont::RasterizeL()

@publishedAll

@released

*/

class TOpenFontGlyphData

	{

public:

	IMPORT_C static TOpenFontGlyphData* New(RHeap* aHeap,TInt aBufferSize);

	inline TBool Overflow() const;

	inline TInt BytesNeeded() const;

	inline TPtrC8 Bitmap() const;

	inline const TUint8* BitmapPointer() const;

	inline const TOpenFontCharMetrics* Metrics() const;

	inline TInt GlyphIndex() const;

	inline TUint8* BufferStart();

	inline TUint8* BufferEnd();

	inline void SetBytesNeeded(TInt aBytes);

	inline void SetBitmapPointer(const TUint8* aBitmap);

	inline void SetMetricsPointer(const TOpenFontCharMetrics* aMetrics);

	inline void SetPointersToInternalBuffers();

	inline void SetMetrics(TOpenFontCharMetrics& aMetrics);

	inline void SetGlyphIndex(TInt aGlyphIndex);

private:

	/*

	Prevent construction and destruction by normal means; the object resides 

	on a specified heap and is created by New and deleted by RHeap::Free.

	*/

	TOpenFontGlyphData();

	~TOpenFontGlyphData();

private:

	TInt iBitmapBufferSize;					// size of the buffer in bytes

	TInt iBytesNeeded;						// bytes needed for the bitmap

	TOpenFontCharMetrics iMetricsBuffer;	// the metrics

	const TUint8* iBitmap;					// pointer to the bitmap; points either to iBitmapBuffer or to

											// the cache if the character was already rasterized

	const TOpenFontCharMetrics* iMetrics;	// pointer to the metrics; points either to iMetricsBuffer or to

											// the cache if the character was already rasterized

	TInt iGlyphIndex;						// the glyph index

	TAny* iReserved;						// unused; for future expansion

	TUint8 iBitmapBuffer[1];				// buffer used to write the bitmap when it is first rasterized; this

											// is actually of size iBitmapBufferSize.

	};

class COpenFontGlyph;

/**

Open Font System font abstract base class.

Derive a class from this class to represent an instance of a typeface at a 

particular size, provide bitmaps of the glyphs, and determine whether 

characters exist in the typeface.

Writing derived classes construction: 

You must call the constructor of this class when creating your derived object, 

passing the arguments aHeap and aSessionCacheList supplied to 

COpenFontFile::GetNearestFontInPixelsL(), and the address of the COpenFontFile 

object that creates the object as aFile.

The derived object must be created on the shared heap aHeap because it is 

shared by several processes: the font and bitmap server and its clients. 

To do this, use aHeap->AllocL() to obtain memory, then construct in place 

using a placement argument to new.

Derived classes must implement the pure virtual function RasterizeL(). 

Information about this function is provided in the function definition below. 

Information about deriving from this class is also provided in the API guide.

@see	COpenFontFile::GetNearestFontInPixelsL()

@publishedAll

@released

*/

class COpenFont: public CBase

	{

public:

	/** Creates a bitmap for the specified Unicode character.

	Implementations of this function should put the bitmap in 

	aGlyphData->iBitmapBuffer, and the character metrics are placed in 

	aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left 

	alone. 

	There are a number of strategies for achieving this, e.g. pass the 

	rasterization task all the way up to the rasterizer engine. These are 

	discussed in the API guide.

	At present you must write the bitmap in the Symbian platform's 

	run-length-encoded format. This is a packed binary format starting on a 

	byte boundary and made up of a number of sections. Each section starts 

	with a five-bit header. If the first bit of the header is 0 the next four 

	bits are a repeat count, starting with the least significant bit, and a 

	single row of bits (the number of bits in a row is specified by 

	aGlyphData->iMetricsBuffer.Width()) follows. If the first bit of the header 

	is 1 the next four bits are a count of non-repeating rows, again starting 

	with the least significant bit, and that many rows of bits follow.

	@param aCode The character code of the Unicode character for which the 

	bitmap is required.

	@param aGlyphData On return, contains a pointer to a TOpenFontGlyphData 

	containing the character's bitmap and metrics. */

	virtual void RasterizeL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0;

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

	IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile);

	IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile,TInt aFaceIndex);

	IMPORT_C ~COpenFont();

	IMPORT_C void operator delete(TAny*);

	inline const TOpenFontMetrics& Metrics() const;

	inline const TOpenFontFaceAttrib* FaceAttrib() const;

	inline COpenFontFile* File() const;

	inline TInt FaceIndex() const;

	inline TBool CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const;

	void SetShaper(CShaper* aShaper);

	CShaper* GetShaper();

	TBool HasShaper() const;

	TShapeHeader* GetShapedData(TInt aSessionHandle,TFontShapeFunctionParameters* aParams);

	TShapeHeader* InsertShapedDataIntoCache(TInt aSessionHandle,TFontShapeFunctionParameters* aParams, TShapeHeader* aShapeHeader);

	TInt FreeShaperCacheMemory(TInt aBytesNeeded);

	TInt DecrementCachedRefCount(TInt aSessionHandle,TShapeHeader* aShapeHeader,TBool aResetAll=EFalse);

	TBool Rasterize(TInt aSessionHandle,TInt aCode,TOpenFontGlyphData* aGlyphData);

	TBool HasCharacterL(TInt aCode) const;

	TBool GetCharacterData(TInt aSessionHandle,TInt aCode,const TOpenFontCharMetrics*& aMetrics,const TUint8*& aBitmap) const;

	void OnFileDeleted();

	COpenFontGlyphCache* GetGlyphCache();

	inline TInt FontCapitalAscent() const;

	inline TInt FontMaxAscent() const;

	inline TInt FontStandardDescent() const;

	inline TInt FontMaxDescent() const;

	inline TInt FontLineGap() const;

	inline TInt FontMaxHeight() const;

	void DeleteShaper() const;

	TInt GetFontTable(TUint32 aTag, TAny*& aTableContent, TInt& aLength);

	TInt GetGlyphOutline(TUint aCode, TBool aHinted, TAny*& aOutline, TInt& aLength);

protected:	

	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

	*/

	TInt PointerToThisOffset(const TAny* aAny);

	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

	*/

	TAny* ThisOffsetToPointer(const TInt aOffset);

protected:

	RHeap* iHeap;

	TOpenFontMetrics iMetrics;

private:

	/** The shaper for performing complex character positioning and

	substitution, if available. Null otherwise.

	WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. 

    */

	CShaper* iShaper;

protected:

	/** The positive distance in pixels from the baseline to

		the top of an ANSI capital (whether or not there are

		ANSI capitals in the font) */

	TInt iFontCapitalAscent;

	/** The positive distance in pixels from the baseline to

		the top of the highest pre-composed glyph in the font */

	TInt iFontMaxAscent;

	/** The positive distance in pixels from the baseline to

		the bottom of the lowest ANSI descender (whether or

		not there are ANSI chars in the font)*/

	TInt iFontStandardDescent;

	/** The positive distance in pixels from the baseline to

		the bottom of the lowest pre-composed glyph in the font */

	TInt iFontMaxDescent;

	/** The recommended baseline to baseline gap for successive

		lines of text in the font */

	TInt iFontLineGap;

private:

	const COpenFontGlyph* Glyph(TInt aSessionHandle,TInt aCode) const;

protected:

	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

	*/

	const COpenFontGlyph* FontCacheGlyph(TInt aCode,TInt*& aNode);

	const COpenFontGlyph* FontCacheGlyph(TInt aCode);

	void SetGlyphCache(COpenFontGlyphCache* aGlyphCache);

private:

	const COpenFontGlyph* SessionCacheGlyph(RHeap* aHeap,TInt aSessionHandle,TInt aCode,

											COpenFontSessionCache*& aCache,TInt& aIndex,TBool aCreate) const;

	void RasterizeHelperL(TInt aCode,TOpenFontGlyphData* aGlyphData,TOpenFontGlyphData*& aTempGlyphData);

	COpenFontSessionCacheList* SessionCacheList()const;

    void SetSessionCacheList(COpenFontSessionCacheList* aSessionCacheList);

    void SetFile(COpenFontFile* aFile);

private:

    // Offset from the address of the file used by this font.

    // If the file has been deleted or cannot be used, the offest will be zero.

    TInt iFileOffset;

	TInt iFaceIndex;										// index of the face in the font file

protected:

    /**

    WARNING: Compatibility is not guaranteed in future releases. Please use the provided APIs only.

    Offset from the address of this font of the per-font glyph cache which is owned by the font

    @internalTechnology

    */  

    TInt iGlyphCacheOffset;

private:

    // Offset from the address of this font of the list of per-session glyph

    // caches which are owned by CFontStore

    TInt iSessionCacheListOffset;

	TAny* iReserved; // unused; for future expansion

	};

/** Open Font System Extension Interface abstract base class.

COpenFont derivers should also derive from this interface to enable complex

font "shaping".

This interface should be returned by the overridden

COpenFont::ExtendedInterface function when KUidOpenFontShapingExtension is

supplied as the UID.

@see	COpenFont

@see	KUidOpenFontShapingExtension 

@publishedAll

@released

*/

class MOpenFontShapingExtension

	{

public:

	/** Various font metrics. */

	class TExtensionFontMetrics

		{

	public:

		/** The number of font design units per em. */

		TInt iUnitsPerEm;

		/** The width of the font's em square in pixels. */

		TReal iXPixelsPerEm;

		/** The height of the font's em square in pixels. */

		TReal iYPixelsPerEm;

		/** The horizontal scaling factor from the font's transform;

		the number of horizontal pixels per font unit. */

		TReal iXScaleFactor;

		/** The vertical scaling factor from the font's transform;

		the number of vertical pixels per font unit. */

		TReal iYScaleFactor;

	private:

		/** Reserved for future expansion. */

		TInt iReserved[4];

		};

	/** Creates a bitmap for the specified Glyph code.

	Implementations of this function should put the bitmap in

	aGlyphData->iBitmapBuffer, and the character metrics are placed in

	aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left

	alone.

	This function provides the same functionality as the

	COpenFont::RasterizeL() except that the glyph code is supplied rather than

	the unicode.

	For more information:

	@see	COpenFont::RasterizeL()

	@param	aCode		The glyph code of the character for which the bitmap is required.

	@param	aGlyphData	The function puts its output here.

	*/

	virtual void RasterizeGlyphL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0;

	/** Maps a character to a glyph index.

	@param aUnicodeCharacter Unicode character code to be mapped.

	@return Glyph code corresponding to aUnicodeCharacter. */

	virtual TInt GlyphIndex(TInt aUnicodeCharacter) const = 0;

	/** Returns the hinted pixel coordinates of a particular point in the

	outline of the given glyph.

	@param aGlyphPoint The glyph index.

	@param aPointNumber The number of the point.

	@param aX Returns the point's X pixel value.

	@param aY Returns the point's Y pixel value.

	@return True on success, false otherwise. */

	virtual TBool GlyphPointInHintedPixels(TInt aGlyphIndex, TInt aPointNumber,

		TReal& aX, TReal& aY) const = 0;

	/** Returns the coordinates of a particular (unhinted) point in the outline

	of the given glyph in font units.

	@param aGlyphPoint The glyph index.

	@param aPointNumber The number of the point.

	@param aX Returns the point's X co-ordinate in font units.

	@param aY Returns the point's Y co-ordinate in font units.

	@return True on success, false otherwise. */

	virtual TBool GlyphPointInFontUnits(TInt aGlyphIndex, TInt aPointNumber,

		TInt& aX, TInt& aY) const = 0;

	/** Returns font metrics.

	@param aOut Font metrics returned. */

	virtual void GetExtensionFontMetrics(TExtensionFontMetrics& aOut) = 0;

	};

/** TrueType extension for Open Fonts.

If an open font is able to load TrueType or OpenType tables it should derive

from this class.

This class will be used by 

This interface should be returned by the overridden

COpenFont::ExtendedInterface function when KUidOpenFontTrueTypeExtension is

supplied as the UID.

@see	KUidOpenFontTrueTypeExtension

@publishedAll

@released

*/

class MOpenFontTrueTypeExtension

	{

public:

	/** Returns the specified table. The table need not be released by the

	caller, so the deriver is responsible for ensuring that any memory

	allocated is ultimately cleaned up. The caller must not delete or modify

	the data returned.

	@param aError

		Returns KErrNone if successful or one of the system-wide error codes if

		unsuccessful. Returns KErrNotSupported if the table does not exist in

		the font file.

	@param aTag

		The tag of the table, with the first character in the most significant

		byte. For example, the "vhea" table is obtained by passing in 'v'<<24 |

		'h'<<16 | 'e'<<8 | 'a'.

	@param aLength

		The length of the table in bytes that has been returned or 0 if

		unsuccessful.

	@return The table, if successful.

	@see ReleaseTrueTypeTable */

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

	/** Releases a table obtained by GetTrueTypeTable. The caller must not

	use the table after this call.

	@param aTable The table to be released.

	@see GetTrueTypeTable */

	virtual TInt ReleaseTrueTypeTable(TAny* aTable) = 0;

	/** Determines if the font file has a particular table.

	@param aTag The tag of the table as for GetTrueTypeTable.

	@return True if the table exists in the font file, false otherwise.

	@see GetTrueTypeTable */

	virtual TBool HasTrueTypeTable(TUint32 aTag) = 0;

	};

class MOpenFontGlyphOutlineExtension 

    {

public:

    virtual TInt GetGlyphOutline(TUint aCode, TBool aIsGlyphId, 

            TBool aHinted, TAny*& aOutline, TInt& aLength) = 0;

    };

/** 

Font attribute base class. 

This class is not intended for user derivation.

@see	TOpenFontFaceAttrib

@see	TOpenFontSpec

@publishedAll

@released

*/

class TOpenFontFaceAttribBase

	{

public:

	inline TOpenFontFaceAttribBase();

	inline TBool HasLatin() const;

	inline TBool HasGreek() const;

	inline TBool HasCyrillic() const;

	inline TBool HasKana() const;

	inline TBool HasHangul() const;

	inline TBool HasCJK() const;

	inline TBool IsSymbol() const;

	inline TBool IsBold() const;

	inline TBool IsItalic() const;

	inline TBool IsSerif() const;

	inline TBool IsMonoWidth() const;

	inline TPtrC Name() const;

	inline const TUint* Coverage() const;

	inline void SetName(const TDesC& aName);

	inline void SetCoverage(TUint aCoverage0,TUint aCoverage1 = 0,TUint aCoverage2 = 0,TUint aCoverage3 = 0);

	inline void SetBold(TBool aBold);

	inline void SetItalic(TBool aItalic);

	inline void SetSerif(TBool aSerif);

	inline void SetMonoWidth(TBool aMonoWidth);

	inline TBool operator==(const TOpenFontFaceAttribBase& aAttrib) const;

	// Unicode ranges for iCoverage[0] (see the TrueType documentation for other values which are not included)

	enum

		{

		ELatinSet = 0x1,			// 0000-007F

		EGreekSet = 0x80,			// 0370-03FF

		ECyrillicSet = 0x200,		// 0400-04FF

		EArmenianSet = 0x400,		// 0530-058F

		EHebrewSet = 0x800,			// 0590-05FF

		EArabicSet = 0x2000,		// 0600-06FF

		EDevanagariSet = 0x8000,	// 0900-097F

		EBengaliSet = 0x10000,		// 0980-09FF

		EGurmukhiSet = 0x20000,		// 0A00-0A7F

		EGujuratiSet = 0x40000,		// 0A80-0AFF

		EOriyaSet = 0x80000,		// 0B00-0B7F

		ETamilSet = 0x100000,		// 0B80-0BFF

		ETeluguSet = 0x200000,		// 0C00-0C7F

		EKannadaSet = 0x400000,		// 0C80-0CFF

		EMalayalamSet = 0x800000,	// 0D00-0D7F

		EThaiSet = 0x1000000,		// 0E00-0E7F

		ELaoSet = 0x2000000,		// 0E80-0EFF

		EGeorgianSet = 0x8000000,	// 10A0-10FF

		EHangulJamoSet = 0x10000000,// 1100-11FF

		};

	// Unicode ranges for iCoverage[1]

	enum

		{

		ESymbolSets = 0xFFFE,

		EKanaSets = 0x60000,

		EHangulSet = 0x100000,

		ECJKSet = 0x8000000

		};

	// Attribute flags

	enum

		{

		EBold = 0x1,			// weight > 500 in Windows terms

		EItalic = 0x2,			// italic or oblique - any forward slant counts

		ESerif = 0x4,			// characters have serifs

		EMonoWidth = 0x8		// all characters are the same width

		};

	// Other constants

	enum

		{

		ENameLength = 32		// we allow 32 but names that are compatible with old-style fonts are limited to 24

		};

protected:

	TBufC<ENameLength> iName;				// the name of the typeface; whether this is the full name or family name

											// or is in English or another language depends on the context

	TUint iCoverage[4];						// bitmap of the character sets supported by the typeface;

											// these are the same as the fields ulUnicodeRange1 .. ulUnicodeRange4

											// in the OS/2 table in TrueType fonts

	TInt iStyle;							// bold, italic serif, and mono-width

	TInt32 iReserved;

	};

/** 

Typeface attributes.

These attributes include the name, family name, and supported scripts.

@see	CFbsFont::GetFaceAttrib()

@publishedAll

@released

*/

class TOpenFontFaceAttrib: public TOpenFontFaceAttribBase

	{

public:

	inline TOpenFontFaceAttrib();

	inline TBool operator==(const TOpenFontFaceAttrib& aAttrib) const;

	inline TPtrC FullName() const;

	inline TPtrC FamilyName() const;

	inline TPtrC LocalFullName() const;

	inline TPtrC LocalFamilyName() const;

	inline TPtrC ShortFullName() const;

	inline TPtrC ShortFamilyName() const;

	inline TPtrC ShortLocalFullName() const;

	inline TPtrC ShortLocalFamilyName() const;

	inline void SetFullName(const TDesC& aName);

	inline void SetFamilyName(const TDesC& aName);

	inline void SetLocalFullName(const TDesC& aName);

	inline void SetLocalFamilyName(const TDesC& aName);

	inline TInt MinSizeInPixels() const;

	inline void SetMinSizeInPixels(TInt aSize);

private:

	TBufC<ENameLength> iFamilyName;			// the name without any style suffixes; usually a truncation of iFullName

	TBufC<ENameLength> iLocalFullName;		// the full name in the language of the current locale

	TBufC<ENameLength> iLocalFamilyName;	// the family name in the language of the current locale

	TInt iMinSizeInPixels;					// minimum supported size, (or readable size if scalable) in pixels

	TInt32 iReserved2;

	};

/**

Font specification allowing more attributes to be specified than TFontSpec.

In addition to the attributes specified by TFontSpec, this font specification 

allows stretching and slanting in the x dimension, and other algorithmic effects. 

This is used to correct for non-square pixels, and to allow algorithmic slanting 

and bold. The width factor and slant factor transform any point (x,y) to (x 

* iWidthFactor + y * iSlantFactor,y). The width and slant factors are 16.16 

fixed-point numbers.

The font specification also provides access to information about the scripts 

which are supported by the font. This information is not always reliable, 

because it may be incorrectly specified, or not specified at all, by some 

font manufacturers. 

@publishedAll

@released

*/

class TOpenFontSpec : public TOpenFontFaceAttribBase

	{

public:

	IMPORT_C TOpenFontSpec();

	IMPORT_C TOpenFontSpec(const TFontSpec& aFontSpec);

	IMPORT_C void operator=(const TFontSpec& aFontSpec);

	inline TBool operator==(const TOpenFontSpec& aFontSpec) const;

	TBool operator!=(const TOpenFontSpec& aOpenFontSpec) const;

	IMPORT_C void SetAttrib(const TOpenFontFaceAttribBase& aAttrib);

	IMPORT_C void GetTFontSpec(TFontSpec& aFontSpec) const;

	IMPORT_C void CompensateForAspectRatio(TInt aPixelWidth,TInt aPixelHeight);

	IMPORT_C void CompensateForAspectRatio(const MGraphicsDeviceMap& aMap);

	inline TInt Height() const;

	inline TInt32 WidthFactor() const;

	inline TInt32 SlantFactor() const;

	inline TGlyphBitmapType BitmapType() const;

	inline TUint32 Effects() const;

	inline TFontPrintPosition PrintPosition() const;

	inline void SetHeight(TInt aHeight);

	inline void SetWidthFactor(TInt32 aWidthFactor);

	inline void SetSlantFactor(TInt32 aSlantFactor);

	inline void SetBitmapType(TGlyphBitmapType aBitmapType);

	inline void SetEffects(TUint32 aEffects);

	IMPORT_C void SetEffects(FontEffect::TEffect aEffect, TBool aOn);

	IMPORT_C TBool IsEffectOn(FontEffect::TEffect aEffect) const;

	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);

	IMPORT_C TInt ScriptTypeForMetrics() const;

	static TBool IsCompensationForAspectRatioNeeded(TInt aPixelWidth, TInt aPixelHeight);

	static TInt ApplyRatio(TInt& aValue,TInt aNumerator,TInt aDenominator);

	static TInt ApplyRatio(TInt32& aValue,TInt aNumerator,TInt aDenominator);

public:

	/** Algorithmic effects flags.

	These can be combined using an OR operation.

	WARNING: Enum for internal and partner use ONLY.  Compatibility is not guaranteed in future releases.

	@deprecated Use FontEffect::TEffect instead.

	*/

	enum

		{

		/** Font is algorithmic bold. */

		EAlgorithmicBold = 1,

		/** Font has a drop shadow. */

		EDropShadow = 2,

		/** Font is an outline font. */

		EOutline = 4

		};

private:

	void SetScriptTypeForMetrics(TInt aScript);

	void SetSymbol(TBool aSymbol);

	TBool Symbol() const;

	IMPORT_C TBool OperatorEquality(const TOpenFontSpec& aOpenFontSpec) const;

	IMPORT_C TUint32 DoEffects() const;

	IMPORT_C void DoSetEffects(TUint32 aEffects);

private:

	TInt iHeight;						// em height

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

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

	TInt iBitmapType;					// non-anti-aliased, standard anti-aliased, etc.; zero means 'default'

	TUint32 iEffects;					// bit flags for font effects

	TInt iSymbol;						// a symbol font as understood by TFontSpec (bit 1), script type (bits 2-5)

	// The following data member exists only to allow round-trip conversion between TFontSpec and TOpenFontSpec

	TFontPrintPosition iPrintPosition;	// normal, superscript or subscript

	TInt iReserved2;

	};

/**

Font file abstract base class.

Write a class derived from COpenFontFile to manage a file with the font format 

supported by your DLL. The derived class must implement the virtual 

GetNearestFontInPixelsL() function. This function takes a font description 

and creates a COpenFont derived object if the description matches a typeface 

contained in the font file.

Derived classes must also load typeface attributes from the file into the 

protected typeface attribute array during construction. This array is what 

is searched when getting font attribute information see AddFaceL(), 

GetNearestFontHelper().

Writing derived classes  construction:

Call the COpenFontFile constructor in the constructor for your derived object, 

passing it aUid and aFileName arguments. These values are the arguments passed 

when the constructor is called by COpenFontRasterizer::NewFontFileL().

A file may contain one or more typefaces. During construction the derived 

object should extract the information for each typeface and add it to this 

object's protected typeface attribute array see AddFaceL(). This process 

will probably leave under some conditions. It should therefore be implemented 

in a second phase constructor.

Writing derived classes  implement the pure virtual functions:

Derived classes must also implement the two pure virtual functions 

GetNearestFontInPixelsL() and HasUnicodeCharacterL(). Information about 

these functions is provided in the definitions below. Information about 

deriving from this class is also provided in the API guide. 

@see	COpenFontRasterizer::NewFontFileL()

@see	CWsScreenDevice::AddFile()

@publishedAll

@released

*/

class COpenFontFile : public CBase

	{

public:

	/**

	Gets the font which is the nearest to the given font specification.

	Implementations of this pure virtual function should create the COpenFont 

	derived object that most closely matches aDesiredFontSpec, while fitting within

	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

	e.g. if the font name doesn't match, aFont should be set to NULL.

	The other two arguments, aHeap and aSessionCacheList, should be passed to 

	the COpenFont constructor.

	Implementations may use the utility function GetNearestFontHelper()

	to get the attributes of the closest matching font.

	@param	aHeap				Shared heap. This value should be passed to the 

								COpenFont derived classes' constructor.

	@param	aSessionCacheList	The session cache list. This value should be passed 

								to the COpenFont derived classes' constructor.

	@param	aDesiredFontSpec	The desired font specification.

	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

								the algorithmic slant of the typeface.

	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

								the algorithmic slant of the typeface.

	@param	aFont				On return, contains a pointer to the newly created COpenFont 

								derived object, or NULL if no font matching aDesiredFontSpec exists.

	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

	@see	GetNearestFontHelper()

	*/

	virtual void GetNearestFontInPixelsL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec) = 0;

	/**

	Gets the font which is the nearest to the given font specification.

	Implementations of this pure virtual function should create the COpenFont 

	derived object that most closely matches aDesiredFontSpec, while fitting within

	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

	e.g. if the font name doesn't match, aFont should be set to NULL.

	The other two arguments, aHeap and aSessionCacheList, should be passed to 

	the COpenFont constructor.

	Implementations may use the utility function GetNearestFontHelper()

	to get the attributes of the closest matching font.

	@param	aHeap				Shared heap. This value should be passed to the COpenFont 

								derived classes' constructor.

	@param	aSessionCacheList	The session cache list. This value should be passed 

								to the COpenFont derived classes' constructor.

	@param	aDesiredFontSpec	The desired font specification.

	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

								the algorithmic slant of the typeface.

	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

								the algorithmic slant of the typeface.

	@param	aFont				On return, contains a pointer to the newly created COpenFont 

								derived object, or NULL if no font matching aDesiredFontSpec exists.

	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

	@see	GetNearestFontHelper()

	*/

	virtual void GetNearestFontToDesignHeightInPixelsL(

		RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/,

		const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/,

		COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/) {}

	/**

	Gets the font which is the nearest to the given font specification.

	Implementations of this pure virtual function should create the COpenFont 

	derived object that most closely matches aDesiredFontSpec, while fitting within

	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

	e.g. if the font name doesn't match, aFont should be set to NULL.

	The other two arguments, aHeap and aSessionCacheList, should be passed to 

	the COpenFont constructor.

	Implementations may use the utility function GetNearestFontHelper()

	to get the attributes of the closest matching font.

	@param	aHeap				Shared heap. This value should be passed to the COpenFont 

								derived classes' constructor.

	@param	aSessionCacheList	The session cache list. This value should be passed 

								to the COpenFont derived classes' constructor.

	@param	aDesiredFontSpec	The desired font specification.

	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

								the algorithmic slant of the typeface.

	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

								the algorithmic slant of the typeface.

	@param	aFont				On return, contains a pointer to the newly created COpenFont 

								derived object, or NULL if no font matching aDesiredFontSpec exists.

	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

	@param	aMaxHeight			The maximum height (vertical extent) within which the font must fit.

	@see	GetNearestFontHelper()

	*/

	virtual void GetNearestFontToMaxHeightInPixelsL(

		RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/,

		const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/,

		COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/, TInt /*aMaxHeight*/) {}

	/** Tests whether a specified typeface contains a particular character.

	@param	aFaceIndex	The index of the typeface to be tested.

	@param	aCode		The Unicode character code for the character to be tested. 

	@return	ETrue if the typeface contains aCode, otherwise EFalse. */

	virtual TBool HasUnicodeCharacterL(TInt aFaceIndex,TInt aCode) const = 0; 

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

	IMPORT_C COpenFontFile(TInt aUid,const TDesC& aFileName);

	IMPORT_C ~COpenFontFile();

	IMPORT_C TBool GetNearestFontHelper(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

										TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const;

	IMPORT_C void AddFaceL(const TOpenFontFaceAttrib& aAttrib);

	inline TUid Uid() const;

	inline const TDesC& FileName() const;

	inline const TOpenFontFaceAttrib& FaceAttrib(TInt aFaceIndex) const;

	inline TInt FaceCount() const;

	inline void IncRefCount();

	inline TBool DecRefCount();

	TInt GetNearestFontInPixels(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

	TInt GetNearestFontToDesignHeightInPixels(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

	TInt GetNearestFontToMaxHeightInPixels(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

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

	void RemoveFontFromList(const COpenFont* aFont);

	void SetFontStoreL(CFontStore* aFontStore);

	CFontStore* GetFontStore();

	CArrayPtrFlat<COpenFont>* GetOpenFontList();

protected:

	IMPORT_C TBool GetNearestFontHelperOld(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

										TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const;

private:

	// A class to contain the public font attributes and private positioning information (for kerning, ligatures, etc.)

	class TAttrib: public TOpenFontFaceAttrib

		{

	public:

		COpenFontPositioner* iPositioner;	// if non-null, positioning information for the typeface

		};

	static TInt ScoreByName(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib);

	static TInt ScoreByStyle(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib);

	void GetNearestFontToDesignHeightInPixelsAndAddToListL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

	void GetNearestFontToMaxHeightInPixelsAndAddToListL(

		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

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

private:

	CArrayFixFlat<TAttrib> iFaceAttrib;

	TUid iUid;

	TBuf<KMaxFileName> iFileName;

	TInt iRefCount;

	CArrayPtrFlat<COpenFont> iFontList;

	TOpenFontFileData* iData;

	};

/**

Convenience class from which rasterizer contexts may be derived.

A rasterizer context object may (optionally) be created to provide the link 

between the rasterizer DLL code supported by the Open Font System, and the 

rasterizer engine code. A rasterizer context object class should get the 

requested bitmap from the associated rasterizer engine. It should then convert 

this into Symbian run-length-encoded format. This class contains convenience 

functions to make the conversion easier.

Deriving from this class is described in greater detail in the API guide.