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

//

#ifndef __GDI_H__

#define __GDI_H__

#include <e32base.h>

#include <f32file.h>

#include <s32std.h>

#include <displaymode.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS	

#include <graphics/gdi/glyphsample.h>

#include <graphics/gdi/gdiconsts.h>

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS	

class TOpenFontCharMetrics;

class RShapeInfo;

class CGraphicsContext;

class TTextParameters;

/**

Number of twips per inch. 

@publishedAll

@released

*/

const TInt KTwipsPerInch=1440;

/**

Number of twips per point.

@publishedAll

@released

*/

const TInt KTwipsPerPoint=20;

/**

Number of points per inch. 

@publishedAll

@released

*/

const TInt KPointsPerInch=72;

/**

Number of twips per cm.

@publishedAll

@released

*/

const TInt KTwipsPerCm=567;

#if defined(__NO_CLASS_CONSTS__)

/**

A4 paper size in twips. 

@publishedAll

@released

*/

#define KA4PaperSizeInTwips TSize(11906,16838)

/** Legal paper size in twips.

@publishedAll

@released

*/

#define KLegalPaperSizeInTwips TSize(12240,20160)

/**

Executive paper size in twips. 

@publishedAll

@released

*/

#define KExecutivePaperSizeInTwips TSize(10440,15120)

/** 

Letter paper size in twips. 

@publishedAll

@released

*/

#define KLetterPaperSizeInTwips TSize(12240,15840)

/**

Com-10 paper size in twips. 

@publishedAll

@released

*/

#define KCom_10PaperSizeInTwips TSize(5940,13680)

/**

Monarch paper size in twips. 

@publishedAll

@released

*/

#define KMonarchPaperSizeInTwips TSize(5580,10800)

/**

DL paper size in twips. 

@publishedAll

@released

*/

#define KDLPaperSizeInTwips TSize(6236,12472)

/**

C5 paper size in twips. 

@publishedAll

@released

*/

#define KC5PaperSizeInTwips TSize(9184,12983)

#else

/**

@publishedAll

@released

*/

const TSize KA4PaperSizeInTwips(11906,16838);

const TSize KLegalPaperSizeInTwips(12240,20160);

const TSize KExecutivePaperSizeInTwips(10440,15120);

const TSize KLetterPaperSizeInTwips(12240,15840);

const TSize KCom_10PaperSizeInTwips(5940,13680);

const TSize KMonarchPaperSizeInTwips(5580,10800);

const TSize KDLPaperSizeInTwips(6236,12472);

const TSize KC5PaperSizeInTwips(9184,12983);

#endif

/**

This enumeration holds the possible panic codes that may be raised 

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

enum TGdiPanic

	{

	/** Not used */

	EGdiPanic_Unknown				= 0,

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

	EGdiPanic_InvalidInputParam		= 1,

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

	EGdiPanic_OutOfText				= 2,

	/** Internal failure. */

	EGdiPanic_Invariant				= 3,

	/** Unused panic codes. Can be reused if needed. */

	EGdiPanic_Unused1				= 4,

	EGdiPanic_Unused2				= 5,

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

	EGdiPanic_TypefaceNameOverflow	= 6,

	};

/** 24-bit RGB colour value with 8 bits each for red, green and blue.

All Graphics drawing functions are specified in terms of a 32-bit TRgb colour 

containing the three colour values plus 8 bits for alpha channel. For hardware which 

does not support 24-bit colour, a mapping from TRgb to display colours is 

performed. 

Generally, the convention for the alpha blending fact is 0 = transparent, 

255 = opaque, unless otherwise stated.  The exception to this are the TRgb constructor 

taking a single value, where the top byte of the passed in parameter is used for 

alpha information and the function Value(), which returns alpha information in the top byte.

In both these cases, 0 means opaque, 255 means transparent.

The supported display modes are enumerated in the TDisplayMode type. In each 

display mode a unique index can represent each physical colours supported, 

and which can be mapped onto a full RGB value. The mappings are as follows: 

16-colour displays use the EGA colour set: black, white, and then both light 

and dark versions of grey, red, green, blue, cyan, magenta and yellow

256-colour displays support 216 colours made up of 6x6x6 RGB values, each 

containing all possible multiples of 51 for R,G,B values. Additionally, all 

remaining 10 shades of pure red, green, blue and grey are represented, by 

adding all remaining multiples of 17. This use of 256 colours is sometimes 

known as the Netscape colour cube.

4096-colour displays effectively support RGB values with 4 bits per primary 

colour

64k-colour displays effectively support RGB values with 5 bits allocated to 

red, 6 to green and 5 to blue

16 million-colour displays support true colour with 8 bits allocated to each 

primary colour

@publishedAll

@released

@see TDisplayMode

@see DynamicPalette */

class TRgb

	{

public:

	inline TRgb();

	inline TRgb(TUint32 aValue);

	inline TRgb(TUint32 aInternalValue, TInt aAlpha);

	inline TRgb(TInt aRed,TInt aGreen,TInt aBlue);

	inline TRgb(TInt aRed, TInt aGreen, TInt aBlue, TInt aAlpha);

	inline TInt Red() const;

	inline TInt Green() const;

	inline TInt Blue() const;

	inline TInt Alpha() const;

	IMPORT_C void SetRed(TInt aRed);

	IMPORT_C void SetGreen(TInt aGreen);

	IMPORT_C void SetBlue(TInt aBlue);

	IMPORT_C void SetAlpha(TInt aAlpha);

	IMPORT_C static TRgb Gray2(TInt aGray2);

	IMPORT_C static TRgb Gray4(TInt aGray4);

	IMPORT_C static TRgb Gray16(TInt aGray16);

	IMPORT_C static TRgb Gray256(TInt aGray256);

	IMPORT_C static TRgb Color16(TInt aColor16);

	IMPORT_C static TRgb Color256(TInt aColor256);

	IMPORT_C static TRgb Color4K(TInt aColor4K);

	IMPORT_C static TRgb Color64K(TInt aColor64K);

	IMPORT_C static TRgb Color16M(TInt aColor16M);

	IMPORT_C TInt Gray2() const;

	IMPORT_C TInt Gray4() const;

	IMPORT_C TInt Gray16() const;

	IMPORT_C TInt Gray256() const;

	IMPORT_C TInt Color16() const;

	IMPORT_C TInt Color256() const;

	IMPORT_C TInt Color4K() const;

	IMPORT_C TInt Color64K() const;

	IMPORT_C TInt Color16M() const;

	inline TBool operator==(const TRgb& aColor) const;

	inline TBool operator!=(const TRgb& aColor) const;

	inline TRgb operator~() const;

	inline TRgb operator&(const TRgb& aColor);

	inline TRgb operator|(const TRgb& aColor);

	inline TRgb operator^(const TRgb& aColor);

	inline TRgb& operator&=(const TRgb& aColor);

	inline TRgb& operator|=(const TRgb& aColor);

	inline TRgb& operator^=(const TRgb& aColor);

	inline TUint32 Value() const;

	inline TUint32 Internal() const;

	inline void SetInternal(TUint32 aInternal);

	IMPORT_C TInt Difference(const TRgb& aColor) const;

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C static TRgb Color16MU(TInt a0RGB);

	IMPORT_C TInt Color16MU() const;

	IMPORT_C static TRgb Color16MA(TUint aARGB);

	IMPORT_C TUint Color16MA() const;

	IMPORT_C static TRgb Color16MAP(TUint aARGB);

	IMPORT_C TUint Color16MAP() const;

	IMPORT_C TUint _Color16MAP() const;

	IMPORT_C static TRgb _Color16MAP(TUint aARGB);

	inline TInt _Gray2() const;

	inline TInt _Gray4() const;

	inline TInt _Gray16() const;

	inline TInt _Gray256() const;

	inline TInt _Color4K() const;

	inline TInt _Color64K() const;

	inline TInt _Color16M() const;

	inline TInt _Color16MU() const;

	inline TUint _Color16MA() const;

	inline static TRgb _Gray2(TInt aGray2);

	inline static TRgb _Gray4(TInt aGray4);

	inline static TRgb _Gray16(TInt aGray16);

	inline static TRgb _Gray256(TInt aGray256);

	inline static TRgb _Color4K(TInt aColor4K);

	inline static TRgb _Color64K(TInt aColor64K);

	inline static TRgb _Color16M(TInt aColor16M);

	inline static TRgb _Color16MU(TInt a0RGB);

	inline static TRgb _Color16MA(TUint aARGB);

private:

	TUint32 iValue;

	};

/**

@publishedAll

@released

*/

#define KRgbBlack		TRgb(0x000000)

#define KRgbDarkGray	TRgb(0x555555)

#define KRgbDarkRed		TRgb(0x000080)

#define KRgbDarkGreen	TRgb(0x008000)

#define KRgbDarkYellow	TRgb(0x008080)

#define KRgbDarkBlue	TRgb(0x800000)

#define KRgbDarkMagenta	TRgb(0x800080)

#define KRgbDarkCyan	TRgb(0x808000)

#define KRgbRed			TRgb(0x0000ff)

#define KRgbGreen		TRgb(0x00ff00)

#define KRgbYellow		TRgb(0x00ffff)

#define KRgbBlue		TRgb(0xff0000)

#define KRgbMagenta		TRgb(0xff00ff)

#define KRgbCyan		TRgb(0xffff00)

#define KRgbGray		TRgb(0xaaaaaa)

#define KRgbWhite		TRgb(0xffffff)

#define KRgbTransparent	TRgb(0x000000,0x00)

/** A set of static utility functions to get information about a display mode. 

@publishedAll 

@released

*/

class TDisplayModeUtils

	{

public:

	IMPORT_C static TBool IsDisplayModeColor(TDisplayMode aDispMode);

	IMPORT_C static TBool IsDisplayModeValid(TDisplayMode aDispMode);

	IMPORT_C static TInt NumDisplayModeColors(TDisplayMode aDispMode);

	IMPORT_C static TInt NumDisplayModeBitsPerPixel(TDisplayMode aDispMode);

	};

/** Provides user-definable palette support to the GDI.

A palette is a user-defined set of colours, which is a subset of the full 

range of 24-bit colours. This allows users the advantages of having a low 

bpp colour mode whilst being able to specify the colours available in that 

mode. To give an example, the EColor16 mode provides a palette of 16 colours 

as it provides a mapping between an integer index and a TRgb colour (see the 

table EGA Low-colour constants). Only a palette of 16 colour enables you to 

change the palette. Palettes are also used to allow 24-bit bitmaps to be stored 

in a more compressed form by finding the actual number of different colours 

used in the bitmap, creating a palette to allow the mapping of these colours 

to a smaller index space, and encoding the bitmaps pixels using indexes 

to this new index space. 

A palette has a size which is set at its creation and cannot be altered 

the number of entries in the palette. Each entry in a palette is a mapping 

between that entrys index and a TRgb value. Palette entries can be got 

and set at any time between the palettes creation and destruction. The 

GDIs palette support also provides functions to find the nearest palette 

colour to a requested TRgb colour. 

@publishedAll

@released

*/

class CPalette : public CBase

	{

public:

	IMPORT_C static CPalette* NewL(TInt aNumberOfEntries);

	IMPORT_C static CPalette* NewDefaultL(TDisplayMode aDispMode);

	IMPORT_C ~CPalette();

	IMPORT_C void Clear();

	inline TInt Entries() const;

	IMPORT_C TRgb GetEntry(TInt aPaletteIndex) const;

	IMPORT_C TRgb NearestEntry(const TRgb& aColor) const;

	IMPORT_C TInt NearestIndex(const TRgb& aColor) const;

	IMPORT_C void SetEntry(TInt aPaletteIndex,const TRgb& aPaletteEntry);

	IMPORT_C void GetDataPtr(TInt aFirstColor,TInt aNumColors,TPtr8& aPtr);

protected:

	IMPORT_C CPalette();

	void ConstructL(TInt aNumberOfEntries);

protected:

	TRgb* iArray;

	TInt iNumEntries;

	};

/** Enables conversion, in both directions, between a TRgb object and an index 

into an arbitrary 256 colour palette. 

@publishedAll 

@released

*/

class TColor256Util

	{

public:

	IMPORT_C void Construct(const CPalette& aPalette);

	IMPORT_C TInt Color256(TRgb aRgb) const;

	IMPORT_C void Color256(TUint8* aDestination,const TRgb* aSource,TInt aNumPixels) const;

	inline TRgb Color256(TInt aColor256) const;

	IMPORT_C static const TColor256Util* Default();

public:

	/** 256 colour lookup table.

	Each entry is a 32 bit value which corresponds to a TRgb value in the 

	palette passed to Construct(). If there are more than 256 colours in the 

	palette, the first 256 colours are used in this table. If there are fewer 

	than 256 entries, the remaining entries in the table are set to zero. */

	TUint32	iColorTable[256];

	/** Inverse colour lookup table.

	It has 4096 entries. Each entry is the index of a colour in the palette 

	that the object was created with (see Construct()) that most closely 

	matches the 4096 degrees of intensity of red, green and blue on a uniform 

	16x16x16 colour cube.

	It is called "inverse" because iColorTable maps indices (0..255) to TRgb 

	values, but this table maps TRgb values to palette indices. */

	TUint8	iInverseColorTable[0x1000];

	};

/** Linear digital differential analyser.

This is used to calculate the pixels which most closely approximate a specified 

straight line, or when scaling a bitmap. Note that a line is infinitely thin, 

and can only be approximated by pixels with real width and height.

Functions are provided for: pixel line traversing; jumping to a rectangle or 

co-ordinate 

@publishedAll 

@released

*/

class TLinearDDA

	{

public:

	/** LDDA Line mode. */

	enum TLineMode

		{

		/** Centres scan-lines in the pixel line */

		ECenter,

		/** Starts at the beginning of a complete scan line. Used for bitmap 

		scaling. */

		ELeft

		};

public:

	IMPORT_C TLinearDDA();

	IMPORT_C TLinearDDA(const TLinearDDA& aLine);

	IMPORT_C void Construct(const TPoint& aStart,const TPoint& aFinish,TLineMode aMode=ECenter);

	IMPORT_C TBool SingleStep(TPoint& aPosition);

	IMPORT_C TBool SingleScanline(TPoint& aStartPosition,TPoint& aEndPosition);

	IMPORT_C TBool NextStep(TPoint& aPosition);

	IMPORT_C void JumpToRect(const TRect& aRect);

	IMPORT_C void JumpToXCoord(const TInt aXCoord,TInt& aYCoord);

	IMPORT_C void JumpToYCoord(TInt& aXCoord,const TInt aYCoord);

	IMPORT_C void JumpToXCoord2(TInt aXCoord,TInt& aYCoord);

	IMPORT_C void JumpToYCoord2(TInt& aXCoord,TInt aYCoord);

private:

	void UpdatePosition();

private:

	enum TLineStatus

		{

		EInitialised,

		ECurrent,

		EComplete

		};

private:

	TInt iCount;

	TSize iDifference;

	TPoint iFinish;

	TInt iGradient;

	TPoint iInc;

	TPoint iPos;

	TPoint iStart;

	TRect iBoundingRect;

	TBool iBoundingRectSet;

	TInt16 iInsideX; // boolean, defined as TInt16 to maintain binary compatibility

	TInt16 iInsideY; // boolean, defined as TInt16 to maintain binary compatibility

	TLineStatus iStatus;

	};

/**

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

	};

/**

Font underline flags. 

@publishedAll	

@released

*/

enum TFontUnderline

	{

	/** Font is not underlined. */

	EUnderlineOff,

	/** Font is underlined. */

	EUnderlineOn

	};

/**

Font strike-through flags. 

@publishedAll	

@released

*/

enum TFontStrikethrough

	{

	/** Font is not struck-through. */

	EStrikethroughOff,

	/** Font is struck-through. */

	EStrikethroughOn

	};

/**

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;

		/** The number of clients accessing the font. */

		TInt iAccessCount;

		};

protected:

	/** A list of fonts accessed by clients of the typeface store, which pairs 

	a font with a count of the number of clients accessing the font.

	Implemented as an array of TFontAccess objects.

	An object is added to this array for every font accessed. If the font is 

	released by all clients, and the access count drops to zero, the font is 

	removed from the list. */

	CArrayFixFlat<TFontAccess>* iFontAccess;

	};

/** The maximum number of entries in the font cache.

@see CFontCache */

const TInt KMaxFontCacheEntries=32;

/** Font cache. 

When a CFont* needs to be found for a particular TFontSpec, the cache can 

be searched to see if the TFontSpec is already in the cache. If the TFontSpec 

is in the cache, its corresponding CFont* can be returned. Otherwise 

GetNearestFontInTwips() must be used to search all of the available fonts for 

the nearest CFont- a procedure which takes much longer than a simple cache

search.

The current font cache should be destroyed and a new cache created whenever 

the zoom factor or device map changes, as these changes break the relation 

between CFont and TFontSpec. 

@publishedAll

@released

*/

class CFontCache : public CBase

	{

public:

	IMPORT_C CFontCache();

	IMPORT_C CFontCache(TInt aMaxEntries);

	IMPORT_C ~CFontCache();

	IMPORT_C CFont* Search(const TFontSpec& aFontSpec);

	IMPORT_C CFont* AddEntryL(CFont* aFont,const TFontSpec& aFontSpec);

	IMPORT_C CFont* RemoveFirstEntry();

public:

	/** The number of cache hits since the font cache was created i.e. 

	successful results from CFontCache::Search(). */

	TInt iNumHits;

	/** The number of cache misses since the font cache was created i.e. 

	unsuccessful results from CFontCache::Search(). */

	TInt iNumMisses;

private:

	class CFontCacheEntry : public CBase

		{

	public:

		CFontCacheEntry(CFont* aFont,const TFontSpec& aFontSpec,CFontCacheEntry* aNext);

	public:

		CFont* iFont;

		TFontSpec iSpec;

		CFontCacheEntry* iNext;

		};

private:

	TInt iNumEntries;

	TInt iMaxEntries;

	CFontCacheEntry* iFirst;

	};

/** Interface class for mapping between twips and device-specific units (pixels).

TZoomFactor is derived from MGraphicsDeviceMap.

@see CGraphicsDevice

@see TZoomFactor 

@publishedAll

@released

*/

class MGraphicsDeviceMap

    {

public:

	IMPORT_C MGraphicsDeviceMap();

	IMPORT_C virtual ~MGraphicsDeviceMap();

	IMPORT_C TPoint TwipsToPixels(const TPoint& aTwipPoint) const;

	IMPORT_C TRect TwipsToPixels(const TRect& aTwipRect) const;

	IMPORT_C TPoint PixelsToTwips(const TPoint& aPixelPoint) const;

	IMPORT_C TRect PixelsToTwips(const TRect& aPixelRect) const;

	/** Converts a horizontal dimension from twips to pixels.