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

// This file is a subset of original gdi.h.

//

// IMPORTANT NOTE to maintainer:

//     If you add new exports, to make sure they are exported by GDI.DLL,

//     remember to update /graphics/graphicsdeviceinterface/gdi/sgdi/TextBaseStub.cpp.

//

// Text related types/consts are moved from gdi.h to this file, as listed below.

//

// enum TFontPosture

// enum TFontStrokeWeight

// enum TFontPrintPosition

//

// const KMaxTypefaceNameLength

// class TTypeface

// enum TGlyphBitmapType

// class FontEffect

// class TFontStyle

// class TFontSpec

// class TTypefaceSupport

// const KSuperSubScalingPercentage

// const KSuperscriptOffsetPercentage

// const KSubscriptOffsetPercentage

// class CTypefaceStore

// const KMaxFontCacheEntries

// class CFontCache

//

// const KFontCapitalAscent

// const KFontMaxAscent

// const KFontStandardDescent

// const KFontMaxDescent

// const KFontLineGap

// const KFontGetFontTable

// const KFontGetGlyphOutline

// const KFontReleaseGlyphOutline

// const KFontReleaseFontTable

// class CFont

#ifndef __TEXTBASE_H__

#define __TEXTBASE_H__

#include <e32base.h>

#include <f32file.h>

#include <s32std.h>

class TOpenFontCharMetrics;

class RShapeInfo;

#ifndef __GLYPHSEL_TEXTBASE_H__

#define __GLYPHSEL_TEXTBASE_H__

/**

This enumeration holds the possible panic codes that may be raised 

by the TextBase API on detecting an unrecoverable error. */

enum TTextBasePanic

	{

	/** Not used */

	ETextBasePanic_Unknown				= 0,

	/** One or more of the input parameters to the interface were invalid */

	ETextBasePanic_InvalidInputParam		= 1,

	/** Insufficient text for successful completion of the method */

	ETextBasePanic_OutOfText				= 2,

	/** Internal failure. */

	ETextBasePanic_Invariant				= 3,

	/** Reserved panic codes. Not to be used. */

	ETextBasePanic_Reserved1				= 4,

	ETextBasePanic_Reserved2				= 5,

	/** Setting a typeface name that is too long */

	ETextBasePanic_TypefaceNameOverflow	= 6,

	};

#endif

/**

Font posture flags.

Fonts can be either upright or italic. 

@publishedAll	

@released

*/

enum TFontPosture

	{

	/** Font posture is normal (upright). */

	EPostureUpright,

	/** Font posture is italic. */

	EPostureItalic

	};

/**

Font stroke weight flags. 

@publishedAll	

@released

*/

enum TFontStrokeWeight

	{

	/** Font stroke weight is normal. */

	EStrokeWeightNormal,

	/** Font stroke weight is bold. */

	EStrokeWeightBold

	};

/**

Font print position flags.

Fonts can be normal, superscript or subscript. 

@publishedAll	

@released

*/

enum TFontPrintPosition

	{

	/** Font is normal. */

	EPrintPosNormal,

	/** Font is superscript. */

	EPrintPosSuperscript,

	/** Font is subscript. */

	EPrintPosSubscript

	};

/**

The maximum length of a typeface name (in characters). 

@publishedAll	

@released

*/

const TInt KMaxTypefaceNameLength=0x18;

/** Typeface name and attributes.

This class identifies a typeface by name, and contains the combination of 

attributes of the typeface. These attributes define whether it is a symbol 

typeface, whether the typeface is proportional, and whether it is serif or 

sans-serif. 

The combination of attributes for a typeface are stored in a bitmask, with 

the various bits indicating different attributes. The bitmask is calculated 

for any particular attribute combination by ORing the enumerated value for 

each individual attribute. 

@publishedAll 

@released

*/

class TTypeface

    {

public:

	enum

		{

		/** Typeface is a proportional typeface (e.g. Swiss)

		*/

		EProportional = 1,

		/** Typeface is a serif typeface (e.g. Times)

		*/

		ESerif = 2,

		/** Typeface is a symbol typeface (e.g. Symbol)

		*/

		ESymbol = 4,

		};

public:

	IMPORT_C TTypeface();

	IMPORT_C TBool operator==(const TTypeface& aTypeface) const;

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C void SetAttributes(TInt aAttributes);

	IMPORT_C void SetIsProportional(TBool aIsProportional);

	IMPORT_C void SetIsSerif(TBool aIsSerif);

	IMPORT_C void SetIsSymbol(TBool aIsSymbol);

	IMPORT_C TInt Attributes() const;

	IMPORT_C TBool IsProportional() const;

	IMPORT_C TBool IsSerif() const;

	IMPORT_C TBool IsSymbol() const;

	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);

	IMPORT_C void SetScriptTypeForMetrics(TInt aScript);

	IMPORT_C TInt ScriptTypeForMetrics() const;

	IMPORT_C void SetName(const TDesC& aName);

	IMPORT_C const TDesC& Name() const;

private:

	void ResetAttributes();

	void ResetScriptType();

public:

	/** The typeface name. */

    TBufC<KMaxTypefaceNameLength> iName;

private:

    TUint32 iFlags;

    };

/**

An enumerated type for the format of a glyph bitmap. This type is currently 

used to indicate whether glyph bitmaps for scalable fonts are drawn anti-aliased. 

Additional values may be defined in the future.

@see TFontStyle::SetBitmapType()

@see CFbsTypefaceStore::SetDefaultBitmapType() 

@publishedAll

@released	

*/

enum TGlyphBitmapType

	{

	/** The font store's default glyph bitmap format is used. */

	EDefaultGlyphBitmap = 0,

	/** The standard monochrome format: no anti-aliasing, 1 bit per pixel, 

	run-length encoded. */

	EMonochromeGlyphBitmap,

	/** Standard 8-bits-per-pixel with anti-aliasing. */

	EAntiAliasedGlyphBitmap,

	/** The format used when sub-pixel font rendering is used. */

	ESubPixelGlyphBitmap,

	/** The format used when outline and shadow font rendering is used. 

	If the raterizer supports the outline and shadow fonts, it will set the bitmaptype as 

	EFourColourBlendGlyphBitmap but only when glyph bitmap type is set as EAntiAliasedGlyphBitmap and 

	when any of the EDropShadow or EOutline effect is on. Only rasterizer providers can use this enum.

	*/

	EFourColourBlendGlyphBitmap,

	/**

	This is used for glyphs, and not fonts, and is needed to inform the font drawing routines

	that the character should be drawn using the overall font setting. 

	For Internal Use Only.

	*/

	EGlyphBitmapTypeNotDefined,

	/**

	This is used to inform the rasterizer that the best match should be

	found for the bitmap type based upon its knowledge.

	For Internal Use Only.

	*/

	EAntiAliasedOrMonochromeGlyphBitmap,

	};

/**

Defines a set of font effects flags.

@publishedAll 

@released

WARNING: This Class is for use by system/UI software ONLY.

*/

NONSHARABLE_CLASS(FontEffect)

	{

public:

	enum TEffect

		{

		ENone			= 0x0,		// No effects.

		EAlgorithmicBold= 0x10,		// Font is algorithmic bold (a.k.a pseudo bold.)

		EDropShadow		= 0x20,		// Font has a drop shadow.

		EOutline		= 0x40,		// Font is an outline font.

		EEmbossed		= 0x80,		// Font is embossed.

		EEngraved		= 0x100,	// Font is engraved.

		ESoftEdge		= 0x200,	// Font is soft edged.

		EReserved1		= 0x400,	// Reserved for Symbian use.

		EReserved2		= 0x800,	// Reserved for Symbian use.

		EReserved3		= 0x1000,	// Reserved for Symbian use.

		EReserved4		= 0x2000,	// Reserved for Symbian use.

		EReserved5		= 0x4000,	// Reserved for Symbian use.

		EReserved6		= 0x8000,	// Reserved for Symbian use.

		};

public:

	IMPORT_C static TBool IsEffectOn(TEffect aEffect, TUint32 aFontEffect);

	IMPORT_C static void SetEffect(TEffect aEffect, TBool aOn, TUint32& aFontEffect);

	};

/** Encapsulates a font style. 

The font style information is comprised of:

the posture of the font upright or italic

the stroke weight of the font  normal or bold

the print position of the font normal, subscript or superscript

Note that the underline and strike-through attributes are not included in 

this class, but are set in the graphics context.

@see CGraphicsContext::SetUnderlineStyle()

@see CGraphicsContext::SetStrikethroughStyle() 

@publishedAll

@released

*/

class TFontStyle

	{

public:

	IMPORT_C TFontStyle();

	IMPORT_C TFontStyle(TFontPosture aPost,TFontStrokeWeight aStrWgt,TFontPrintPosition aPrintPos);

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C TFontPosture Posture() const;

	IMPORT_C TFontStrokeWeight StrokeWeight() const;

	IMPORT_C TFontPrintPosition PrintPosition() const;

	IMPORT_C void SetPosture(TFontPosture aPosture);

	IMPORT_C void SetStrokeWeight(TFontStrokeWeight aStrokeWeight);

	IMPORT_C void SetPrintPosition(TFontPrintPosition aPrintPosition);

	inline TGlyphBitmapType BitmapType() const;

	inline void SetBitmapType(TGlyphBitmapType aBitmapType);

	IMPORT_C TBool operator==(const TFontStyle& aFontStyle) const;

	IMPORT_C TUint32 Effects() const;

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

	IMPORT_C void SetEffects(TUint32 aEffects);

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

private:

	enum

		{

		EItalic=0x1,

		EBold=0x2,

		ESuper=0x4,

		ESub=0x8

		};

private:

	TUint32 iFlags; // bitmap type - 16 bits (high), font effects - 12 bits (middle), style - 4 bits (low)

	TAny* iReserved1;

	TAny* iReserved2;

	};

/**

Specifies the font specification in device independent terms.

@publishedAll 

@released

*/

class TFontSpec

	{

public:

	IMPORT_C TFontSpec();

	IMPORT_C TFontSpec(const TDesC& aTypefaceName,TInt aHeight);

	IMPORT_C TBool operator==(const TFontSpec& aFontSpec) const;

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);

	IMPORT_C TInt ScriptTypeForMetrics() const;

public:

	/** The typeface. */

	TTypeface iTypeface;

	/** The height of the typeface (in twips). */

	TInt iHeight;

	/** The font style of the typeface. */

	TFontStyle iFontStyle;

	};

/** Typeface family support information.

This data-only class includes the name and attributes of a typeface, how many 

font heights are available, its minimum and maximum heights, and whether or 

not it is scaleable  a typeface is scaleable if it supports heights at 

fixed intervals between the minimum and maximum heights. 

@publishedAll 

@released

*/

class TTypefaceSupport

    {

public:

	/** The name and attributes of the typeface. */

    TTypeface iTypeface;

	/** The number of distinct font heights available in the typeface. */

    TInt iNumHeights;

	/** The typeface's minimum font height, in twips. */

    TInt iMinHeightInTwips;

	/** The typeface's maximum font height, in twips. */

    TInt iMaxHeightInTwips;

	/** Whether the typeface is scaleable. ETrue if it is scaleable, otherwise 

	EFalse. */

    TBool iIsScalable; // supports heights from min to max at fixed interval

    };

/**

The percentage used to multiply a normal font height when calculating its 

superscript or subscript height. 

@publishedAll	

@released

*/

const TInt KSuperSubScalingPercentage=67;

/**

The percentage of a font height used to calculate its baseline offset for a 

superscript print position. 

@publishedAll	

@released

*/

const TInt KSuperscriptOffsetPercentage=-28;

/**

The percentage of a font height used to calculate its baseline offset for a 

subscript print position. 

@publishedAll	

@released

*/

const TInt KSubscriptOffsetPercentage=14;

class CFont;

/** Typeface store abstract base interface.

This class provides the interface to a store for typefaces.

See also CFontStore. 

@publishedAll

@released

*/

class CTypefaceStore : public CBase

	{

public:

	IMPORT_C ~CTypefaceStore();

	/**

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

	When the font is no longer needed, call @c ReleaseFont().

	Note that this deprecated function is replaced by the new @c GetNearestFontToDesignHeightInTwips() 

	yielding (virtually) the same result. However clients are strongly encouraged to use the new

	@c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 

	character within any given text string will fit within the given amount of twips, whereas the design 

	height is an aesthetic unit decided by the font designer without strict physical meaning, which 

	may result in cropped characters.

	@param aFont On return, contains a pointer to the nearest font.

	@param aFontSpec The specification of the font to be matched.

	@return KErrNone if successful; a system-wide error code otherwise.

	@publishedAll

	@deprecated Use GetNearestFontToDesignHeightInTwips

	*/

	virtual TInt GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec) = 0;

	/**

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

	When the font is no longer needed, call @c ReleaseFont().

	This new function replaces the deprecated @c GetNearestFontInTwips() yielding (virtually) the 

	same result. However clients are strongly encouraged to use the new

	@c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 

	character within any given text string will fit within the given amount of twips, whereas the design 

	height is an aesthetic unit decided by the font designer without strict physical meaning, which 

	may result in cropped characters.

	@param aFont On return, contains a pointer to the nearest font.

	@param aFontSpec The specification of the font to be matched.

	@return KErrNone if successful; a system-wide error code otherwise.

	@publishedAll

	@released

	*/

	virtual TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec) = 0;

	/**

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

	When the font is no longer needed, call @c ReleaseFont().

	The font and bitmap server returns a pointer to the nearest matching font 

	from those available. Matches to max height of font - this does its best 

	to return a font that will fit within the maximum height specified (but 

	note that variations due to hinting algorithms may rarely result in this 

	height being exceeded by up to one pixel). Problems can also be 

	encountered with bitmap fonts where the typeface exists but doesn't have 

	a font small enough.

	@param aFont On return, contains a pointer to the nearest font.

	@param aFontSpec The specification of the font to be matched.

	@param aMaxHeight The maximum height within which the font must fit.

	@return KErrNone if successful; a system-wide error code otherwise.

	@publishedAll

	@released

	*/

	virtual TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight) = 0;

	/** Gets the number of typefaces supported by the typeface store.

	@return The number of supported typefaces. */

	virtual TInt NumTypefaces() const=0;

	/** Gets typeface information for a specified typeface index.

 	This information is returned in aTypefaceSupport, and

	includes the typeface name and typeface attributes, the number of font

 	heights, the maximum and minimum font heights, and whether it is a

	scaleable typeface.

 	@param aTypefaceSupport On return, if the function executed successfully, 

 	this object contains the typeface information.

  	@param aTypefaceIndex A typeface index number, in the range: zero to

             (NumTypefaces() - 1). */

	virtual void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const=0;

	/** Gets the height of the font with specified height and typeface indices, 

	in twips.

	The value returned is rounded up or down to the nearest font height in twips.

	@param aTypefaceIndex A typeface index number, in the range: 0 to 

	(NumTypefaces() - 1). 

	@param aHeightIndex A font height index number.

	@return The height of the font, in twips. */

	virtual TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const=0;

	IMPORT_C void ReleaseFont(CFont* aFont);

	IMPORT_C static TInt BaselineOffset(TInt aHeight,TFontPrintPosition aPos);

	IMPORT_C static TInt SuperSubHeight(TInt aHeight,TFontPrintPosition aPos);

protected:

	IMPORT_C CTypefaceStore();

	IMPORT_C void ConstructL();

	IMPORT_C void AddFontL(CFont* aFont);

	IMPORT_C TBool IncrementFontCount(const CFont* aFont);

private:

	TBool FindFont(const CFont* aFont, TInt& aIdx) const;

	NONSHARABLE_CLASS(TFontAccess)

	/**

	Pairs a font with a count of how many clients of the typeface store 

	are accessing that font. 

    */

		{

	public:

		/** A device specific font. */

		CFont* iFont;