--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/gdi/inc/GDI.H	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,4129 @@
+// 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:
+//
+
+#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
+	};
+
+
+/** 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;
+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.
+	
+	An implementation is supplied by a derived class.
+	
+	@param aTwips A horizontal dimension of a device in twips. 
+	@return A horizontal dimension of a device in pixels. */
+	virtual TInt HorizontalTwipsToPixels(TInt aTwips) const=0;
+
+	/** Converts a vertical dimension from twips to pixels.
+	
+	An implementation is supplied by a derived class.
+	
+	@param aTwips A vertical dimension of a device in twips. 
+	@return A vertical dimension of a device in pixels. */
+	virtual TInt VerticalTwipsToPixels(TInt aTwips) const=0;
+
+	/** Converts a horizontal dimension from pixels to twips.
+	
+	An implementation is supplied by a derived class.
+	
+	@param aPixels A horizontal dimension of a device in pixels. 
+	@return A horizontal dimension of a device in twips. */
+	virtual TInt HorizontalPixelsToTwips(TInt aPixels) const=0;
+
+	/** Converts a vertical dimension from pixels to twips.
+	
+	An implementation is supplied by a derived class.
+	
+	@param aPixels A vertical dimension of a device in pixels. 
+	@return A vertical dimension of a device in twips. */
+	virtual TInt VerticalPixelsToTwips(TInt aPixels) const=0;
+
+	/**
+	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*/) { return KErrNotSupported; }
+
+	/**
+	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.
+	This overrides the height specified in aFontSpec.
+	@return KErrNone if successful; a system-wide error code otherwise.
+	@publishedAll
+	@released
+	*/
+	virtual TInt GetNearestFontToMaxHeightInTwips(
+		CFont*& /*aFont*/, const TFontSpec& /*aFontSpec*/, TInt /*aMaxHeight*/) { return KErrNotSupported; }
+
+	/** Releases the specified font.
+	
+	It is used to indicate that the specified font is no longer needed for use 
+	by the device map. As fonts can be shared between applications, this 
+	function does not delete the copy of the font from RAM unless the font was 
+	only being used by this particular device map.
+	
+	An implementation is supplied by a derived class.
+	
+	@param aFont A pointer to the font to be released. */
+	virtual void ReleaseFont(CFont* aFont)=0;
+    };
+
+class CGraphicsContext;
+
+/** Specifies the interface for concrete device classes.
+
+It holds information on the capabilities and attributes of a graphics device. 
+The CBitmapDevice and CPrinterDevice classes are derived from CGraphicsDevice.
+
+@see CGraphicsDevice
+@see CPrinterDevice 
+@publishedAll
+@released
+*/
+class CGraphicsDevice : public CBase , public MGraphicsDeviceMap
+    {
+public:
+	/** Gets the display mode of the device.
+	
+	@return The display mode of the device. */
+	virtual TDisplayMode DisplayMode() const=0;
+
+	/** Gets the size of the device area in pixels.
+	
+	@return The width and height of the device area, in pixels */
+	virtual TSize SizeInPixels() const=0;
+
+	/** Gets the size of the device area in twips.
+	
+	@return The width and height of the device area, in twips */
+	virtual TSize SizeInTwips() const=0;
+
+ 	/** Creates a graphics context for the device.
+	
+	@param aGC On return, contains a pointer to the created graphics context. 
+	@return KErrNone, if successful; otherwise, another of the system-wide error 
+	codes. */
+    virtual TInt CreateContext(CGraphicsContext*& aGC)=0;
+
+	/** Gets the number of typefaces supported by the graphics device.
+	
+	@return The number of typefaces supported. */
+    virtual TInt NumTypefaces() const=0;
+
+ 	/** Gets typeface information for a specified typeface.
+	
+	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
+	
+	whether it is a scalable typeface
+	
+	@param aTypefaceSupport On return, contains the typeface information. 
+	@param aTypefaceIndex A typeface index number, in the range: zero to 
+	(NumTypefaces() - 1). 
+	@see NumTypefaces() */
+    virtual void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const=0;
+
+	/** Get the height of a font in twips.
+	
+	The font is identified by typeface and height.
+	
+	The value returned is rounded up or down to the nearest font height in twips.
+	
+	@param aTypefaceIndex An index identifying the typeface, in the range: 0 
+	to (NumTypefaces() - 1). 
+	@param aHeightIndex An index identifying the font height, in the range: 0 
+	to (iNumHeights - 1). Note that iNumHeights is in the TTypefaceSupport 
+	object returned by TypefaceSupport(). 
+	@return The height of the font, in twips. */
+	virtual TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const=0;
+
+	/** Gets the palette attributes of the device.
+	
+	@param aModifiable On return, holds information on whether or not the device's 
+	palette is modifiable (ETrue) or fixed (EFalse). 
+	@param aNumEntries On return, holds the number of entries in the device's 
+	palette. */
+	virtual void PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const=0;
+
+	/** Sets the device's palette.
+	
+	Setting the palette is only possible if the device has a modifiable palette, 
+	which can be determined by calling PaletteAttributes().
+	
+	@param aPalette The new palette for the device. */
+	virtual void SetPalette(CPalette* aPalette)=0;
+
+	/** Gets the device's current palette.
+	
+	This function is only supported if the device has a modifiable palette, 
+	which can be determined by calling PaletteAttributes().
+	
+	@param aPalette On return, holds the device's current palette.
+	@return KErrNone, if successful; otherwise, another of the system-wide error 
+	codes. */
+	virtual TInt GetPalette(CPalette*& aPalette) const=0;
+    };
+
+
+/** 
+Code section range information. 
+
+A code section defines the bitmaps for characters in a specified range -
+the range is stored in objects of this type. 
+@publishedAll
+@deprecated 	This is not used anywhere in version 6.0.
+*/
+class TCodeSection
+	{
+public:
+	/** The beginning of the range. */
+	TInt iStart;
+	/** The end of the range. */
+	TInt iEnd;
+	};
+
+/**
+WARNING: this Class is for internal use ONLY.  Compatibility is not guaranteed in future releases.
+UIDs corresponding to the CFont API extension functions
+@internalTechnology
+*/
+const TUid KFontCapitalAscent	= {0x1020498E};
+const TUid KFontMaxAscent		= {0x10204B10};
+const TUid KFontStandardDescent	= {0x10204B11};
+const TUid KFontMaxDescent		= {0x10205AFC};
+const TUid KFontLineGap			= {0x10204B12};
+
+
+
+/** Abstract font interface.
+
+The CFont class provides a device-independent interface to a device-dependent 
+font usually obtained from a call to GetNearestFont...() on a graphics device. 
+It is used as a handle in CGraphicsContext::UseFont() and to obtain 
+device-dependent information about the font - notably the pixel width of a text 
+string.
+
+@see CFbsFont
+@see CGraphicsContext::UseFont() 
+@publishedAll 
+@released
+*/
+class CFont : public CBase
+	{
+	friend class CTypefaceStore;
+public:
+
+	/** Text direction flags.
+
+	This enum is used in TMeasureTextInput and determines whether the text is 
+	drawn horizontally or vertically. Note: text is drawn vertically in some 
+	styles of Japanese, etc.
+
+	@see TMeasureTextInput */
+	enum TTextDirection
+		{
+	/** Text is drawn horizontally. */
+ 		/** Text is drawn horizontally. */
+   		EHorizontal,
+ 		/** Text is drawn vertically. */
+		EVertical
+		};
+
+	/** Complicated parameter block used for contextual glyph selection, 
+	ligature creation and diacritic placement when drawing text in complex 
+	scripts
+
+	This class declares a constructor, another scoped class, and several other 
+	enums. However this class is unlikely to be useful to third party developers.
+
+	@see CFont::GetCharacterPosition()
+	@see CFont::GetCharacterPosition2()
+	@publishedAll
+	@released
+	*/
+	class TPositionParam
+		{
+	public:
+		/** Standard constructor. */
+		TPositionParam():
+			iDirection(EHorizontal),
+			iFlags(0),
+			iPosInText(0),
+			iOutputGlyphs(0)
+			{
+			}
+
+		enum
+			{
+			EMaxInputChars = 18,	// ligatures cannot be made from more than 18 components
+			EMaxOutputGlyphs = 8	// output can consist of up to 8 characters (one base and 7 combining characters)
+			};
+
+		/**Flags for TPositionParam::iFlags. */
+		enum TFlags
+			{
+			/** Input text is logically ordered not visually ordered. */
+			EFLogicalOrder = 1
+			};
+
+		/** Input: Orientation (EHorizontal or EVertical) in which to draw
+		the text. */
+		TInt16 iDirection;
+		/** Input: Flags from TFlags. */
+		TUint16 iFlags;
+		/** Input: Text containing the characters to be positioned. */
+		TPtrC iText;
+
+		/** Input and output: Position within iText to shape. On exit
+		it will index the first character not positioned */
+		TInt iPosInText;
+		/** Input and output: Pen position. */
+		TPoint iPen;			
+
+		/** Output of GetCharacterPosition and GetCharacterPosition2.
+		@see CFont::GetCharacterPosition
+		@see CFont::GetCharacterPosition2
+		@publishedAll
+		@released */
+		class TOutput
+			{
+		public:
+			/** Standard constructor. */
+			TOutput() : iBitmapSize(TSize::EUninitialized),
+				iBounds(TRect::EUninitialized) {}
+			/** Character or glyph code. */
+			TUint iCode;			
+			/** Bitmap data for the glyph, if available */
+			const TUint8* iBitmap;	
+			/** Size of the bitmap before algorithmic bolding, size 
+			multiplication, etc. */
+			TSize iBitmapSize;		
+			/** Bitmap bounds relative to the original pen position. */
+			TRect iBounds;			
+			};
+
+		/** Information about the glyphs that were output. */
+		TOutput iOutput[EMaxOutputGlyphs];	
+		/** Number of glyphs actually output. */
+		TInt iOutputGlyphs;					
+		};	
+
+
+	/** Input parameter block.
+
+	This is optionally used by CFont::MeasureText(), which is the powerful text 
+	measurement function underlying all the other text measurement functions.
+
+	@see CFont::MeasureText() 
+	@publishedAll
+	@released
+	*/
+	class TMeasureTextInput
+		{
+	public:
+		TMeasureTextInput():
+			iStartInputChar(0),
+			iEndInputChar(KMaxTInt),
+			iDirection(EHorizontal),
+			iFlags(0),
+			iMaxAdvance(KMaxTInt),
+			iMaxBounds(KMaxTInt),
+			iCharJustNum(0),
+			iCharJustExcess(0),
+			iWordJustNum(0),
+			iWordJustExcess(0)
+			{
+			}
+
+		/**Flags for TMeasureTextInput::iFlags. */
+		enum TFlags
+			{
+ 			/** Input text is visually ordered left-to-right. */
+ 			EFVisualOrder = 1,
+ 			/** Input text is visually ordered right-to-left.
+ 			Overrides EFVisualOrder. */
+ 			EFVisualOrderRightToLeft = 2,
+ 			/** Flag to consider side bearings when checking bounds for line-break */
+ 			EFIncludePenPositionInBoundsCheck = 4
+			};
+
+		/** Starting index specifying first input character in iText.
+	
+		Together with iEndInputChar, this allows some context before and 
+		after the measured text to be supplied so that shaping can work 
+		properly. */
+		TInt iStartInputChar;	
+	
+		/** Index specifying the final input character.
+	
+		Together with iStartInputChar, this allows some context before and 
+		after the measured text to be supplied so that shaping can work 
+		properly. */
+		TInt iEndInputChar;		
+	
+		/** The direction in which to draw the text. */
+		TUint16 iDirection;
+	
+		/** Flags from TFlags. */
+		TUint16 iFlags;
+	
+		/** The maximum advance. */
+		TInt iMaxAdvance;		
+		
+		/** The maximum width (or height if drawing vertically) of bounds. */
+		TInt iMaxBounds;		
+	
+		/** The number of glyph groups to be letter-spaced. */
+		TInt iCharJustNum;		
+	
+		/** The amount of space to be used for letter spacing. */
+		TInt iCharJustExcess;	
+		
+		/** The number of spaces to be used for word spacing. */
+		TInt iWordJustNum;		
+	
+		/** The amount of space to be used for word spacing. */
+		TInt iWordJustExcess;	
+		};
+
+	/** Output parameter block.
+
+	This is optionally used by CFont::MeasureText(), which is the powerful text 
+	measurement function underlying all the other text measurement functions.
+
+	@see CFont::MeasureText() 
+	@publishedAll
+	@released
+	*/
+	class TMeasureTextOutput
+		{
+		public:
+		/** The number of input characters that would be drawn.
+	
+		This may be less than the length of the text if a maximum advance or bounding 
+		box size is specified. */
+		TInt iChars;			
+		/** The number of glyphs that would be drawn. */
+		TInt iGlyphs;			
+		/** The number of groups that would be drawn.
+	
+		A group is a base glyph plus one or more combining characters. */
+		TInt iGroups;			
+		/** The number of word spaces (U+0020) that would be drawn. */
+		TInt iSpaces;			
+		/** The bounding box of all the glyphs that would be drawn. */
+		TRect iBounds;			
+		/** The maximum width and height of any glyph. */
+		TSize iMaxGlyphSize;	
+		};
+
+	/**
+	Data availability flags.
+
+	Some fonts like printer fonts may only have width information and can return 
+	ECharacterWidthOnly to show this: the text drawing routines in CFont synthesize 
+	the rest of the data if necessary.
+
+	@see GetCharacterData() 
+	@publishedAll	
+	@released
+	*/
+	enum TCharacterDataAvailability
+		{
+		/** No font information available. */
+		ENoCharacterData,
+		/** Width information only is available. */
+		ECharacterWidthOnly,
+		/** All character data is available. */
+		EAllCharacterData
+		};
+
+private:
+	// virtual functions have been made protected and public non-virtual ones
+	// added to convert CFont to a handle-body pattern. SC is kept throught the
+	// new functions and BC is kept by keeping the protected functions in the
+	// same place in the class, and therefore in the same place in the vtable
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TUid DoTypeUid() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoHeightInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoAscentInPixels() const=0;
+	IMPORT_C virtual TInt DoDescentInPixels() const;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoCharWidthInPixels(TChar aChar) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextWidthInPixels(const TDesC& aText) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoBaselineOffsetInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels,TInt& aExcessWidthInPixels) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoMaxCharWidthInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoMaxNormalCharWidthInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TFontSpec DoFontSpecInTwips() const=0;
+
+protected:	
+	IMPORT_C virtual TCharacterDataAvailability DoGetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics,const TUint8*& aBitmap,TSize& aBitmapSize) const;
+	IMPORT_C virtual TBool DoGetCharacterPosition(TPositionParam& aParam) const;
+	IMPORT_C virtual TInt DoExtendedFunction(TUid aFunctionId, TAny* aParam = NULL) const;
+
+protected:
+	IMPORT_C virtual ~CFont();
+
+public:
+	inline TInt FontCapitalAscent() const;
+	inline TInt FontMaxAscent() const;
+	inline TInt FontStandardDescent() const;
+	inline TInt FontMaxDescent() const;
+	inline TInt FontLineGap() const;
+	inline TInt FontMaxHeight() const;
+
+public:
+	/** Gets run-time identity of the actual font type. This enables safe casting to 
+	a derived type.
+	
+	For example, if the derived type is a CFbsFont, the return value is KCFbsFontUid. 
+	You would need to cast to a CFbsFont to get a character bounding box. Similarly, 
+	a CBitmapFont returns KCBitmapFontUidVal.
+	
+	@return The font-type identifier. */
+	IMPORT_C TUid TypeUid() const;
+
+	/** Gets the font height in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxHeight().
+
+	@return The font height in pixels.
+	@see FontMaxHeight()
+	@deprecated */
+	IMPORT_C TInt HeightInPixels() const;
+
+	/** Gets the font ascent in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxAscent()
+	or in some cases @c FontCapitalAscent().	
+	
+	@return The font ascent in pixels.
+	@see FontCapitalAscent()
+	@see FontMaxAscent()
+	@deprecated */
+	IMPORT_C TInt AscentInPixels() const;
+	
+	/** Gets the font descent in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxDescent()
+	or in some cases @c FontStandardDescent().	
+	
+	@return The font descent in pixels.
+	@see FontStandardDescent() 
+	@see FontMaxDescent()
+	@deprecated */
+	IMPORT_C TInt DescentInPixels() const;
+
+	/** Gets the width in pixels in this font of the specified character.
+	
+	Note: For OpenType fonts this function returns the horizontal advance of
+	the character, which may be different from the actual width.
+	
+	@param aChar The character whose width should be determined. 
+	@return The width in pixels of the specified character in this font. */
+	IMPORT_C TInt CharWidthInPixels(TChar aChar) const;
+
+	/** Gets the width in pixels of the specified descriptor when displayed in this 
+	font.
+	
+	@param aText The descriptor whose width should be determined. 
+	@return The width of the specified descriptor when displayed in this font, 
+	in pixels. */
+	IMPORT_C TInt TextWidthInPixels(const TDesC& aText) const;
+
+	/** Gets the baseline offset in pixels. 
+	
+	The baseline offset is how far a font is raised or lowered from its normal 
+	baseline.
+	
+	@return Offset from normal baseline, in pixels. */
+	IMPORT_C TInt BaselineOffsetInPixels() const;
+
+	/** Gets how much of the specified descriptor can be displayed in this font without 
+	exceeding the specified width.
+	
+	Note:
+	
+	This function does not display any of the descriptor itself - it is used 
+	before display, to test whether the whole descriptor can be displayed.
+	
+	@param aText The descriptor. 
+	@param aWidthInPixels The available width for character display. 
+	@return The number of characters which will be able to be displayed without 
+	exceeding the specified width. The count starts from the beginning of the 
+	descriptor. */
+	IMPORT_C TInt TextCount(const TDesC& aText,TInt aWidthInPixels) const;
+
+	/** Gets how much of the specified descriptor can be displayed in this font without 
+	exceeding the specified width. 
+	
+	It also returns the excess width - defined as the specified available width 
+	minus the width of the portion of the descriptor which can be displayed without 
+	exceeding the available width.
+	
+	@param aText The descriptor. 
+	@param aWidthInPixels The available width for character display. 
+	@param aExcessWidthInPixels The excess width after displaying the portion of 
+	the descriptor, in pixels. 
+	@return The number of characters which will be able to be displayed without 
+	exceeding the specified width. The count starts from the beginning of the 
+	descriptor. */
+	IMPORT_C TInt TextCount(const TDesC& aText,TInt aWidthInPixels,TInt& aExcessWidthInPixels) const;
+
+	/** Gets the width in pixels of the widest character in this font.
+	
+	@return The width of the maximum width character, in pixels. */
+	IMPORT_C TInt MaxCharWidthInPixels() const;
+
+	/** Gets the width in pixels of the widest normal character in this font.
+	
+	Normal characters include all character in a character set except non-alphabetic 
+	characters (e.g. the copyright symbol, or a block graphics symbol, for example).
+	
+	@return The width of the maximum width normal character, in pixels. */
+	IMPORT_C TInt MaxNormalCharWidthInPixels() const;
+
+	/** Gets the font specification of this font in twips.
+	
+	@return The font specification of this font (in twips). */
+	IMPORT_C TFontSpec FontSpecInTwips() const;
+	IMPORT_C TCharacterDataAvailability GetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics,const TUint8*& aBitmap,TSize& aBitmapSize) const;
+	IMPORT_C TBool GetCharacterPosition(TPositionParam& aParam) const;
+	IMPORT_C TInt WidthZeroInPixels() const;
+	IMPORT_C TInt MeasureText(const TDesC& aText, const TMeasureTextInput* aInput = NULL, TMeasureTextOutput* aOutput = NULL) const;
+	IMPORT_C static TBool CharactersJoin(TInt aLeftCharacter, TInt aRightCharacter);
+	IMPORT_C TInt ExtendedFunction(TUid aFunctionId, TAny* aParam = NULL) const;
+	IMPORT_C TBool GetCharacterPosition2(TPositionParam& aParam, RShapeInfo& aShapeInfo) const;
+
+	/** Gets the width in pixels of the specified descriptor when displayed in this 
+	font.
+	
+	@param aText The descriptor whose width should be determined.
+	@param aParam Parameter block that controls how much of aText is measured
+	@return The width of the specified descriptor when displayed in this font, 
+	in pixels. */
+	IMPORT_C TInt TextWidthInPixels(const TDesC& aText,const TMeasureTextInput* aParam) const;
+	};
+
+class CFbsBitmap;
+class CWsBitmap;
+/** Abstract base class for all graphics contexts.
+
+Created by a CGraphicsDevice.
+
+Provides the 'context' in which you are drawing to an associated device, in 
+the sense that it holds the settings for drawing, such as the pen and brush 
+settings (e.g. color, line styles) and the font settings (e.g. bold, underline, 
+italic). These settings are device-independent.
+
+Also provides the clipping region (the visible drawing area).
+
+The settings and clipping area can be updated while drawing.
+
+This class also contains the main drawing functions, and all drawing is done 
+through a CGraphicsContext.
+
+The graphics context deals with pixels of device-dependent size and uses fonts 
+with device-dependent size and representation. The sizes and fonts to be passed 
+to the class functions therefore need to be converted from size-independent 
+units to size-dependent units first. This is done by an MGraphicsDeviceMap 
+derived class. This may be a TZoomFactor or the CGraphicsDevice.
+
+See CGraphicsContext::Reset() for the default graphics context settings immediately 
+after construction.
+
+@see CBitmapContext 
+@publishedAll
+@released
+*/
+class CGraphicsContext : public CBase
+	{
+public:
+
+
+	/** Text alignment.
+	@publishedAll
+	@released
+	*/
+	enum TTextAlign
+		{
+		/** Text is left-aligned. */
+		ELeft,
+		/** Text is centred. */
+		ECenter,
+		/** Text is right-aligned. */
+		ERight
+		};
+
+	/** 
+	Drawing mode components.
+	This enum is not intended to be used directly, but provides components for 
+	the easy specification of drawing modes in the TDrawMode enum. 
+	@publishedAll
+	@released
+	*/
+	enum TDrawModeComponents
+		{
+		/** 1 */
+		EInvertScreen=1,
+		/** 2 */
+		EXor=2,
+		/** 4 */
+		EOr=4,
+		/** 8 */
+		EAnd=8,
+		/** 14 */
+		ELogicalOp=14,
+		/** 16 */
+		EInvertPen=16,
+		/** 32 */
+		EPenmode=32,
+		/** 64 */
+		EWriteAlpha=64,
+		};
+
+
+	/** 
+	Drawing modes.
+
+	This enum builds on the drawing mode components in the TDrawModeComponents 
+	enum.
+
+	If the pen colour is p, brush colour is b and screen colour is s, the effect 
+	of TDrawMode::EDrawModeAND is P=p&s and B=b&s. In other words, the effective 
+	colour of the pen on the screen, P, is that produced by the bitwise ANDing 
+	of the current screen colour and the current pen colour. The effect is similar 
+	for the effective brush colour, B.
+
+	The effective pen and brush colour are given in the table using the key
+	Inputs: pen colour is p, brush colour is b and screen colour is s
+	Outputs: effective brush colour is B, effective pen colour is P. 
+
+	Some notes on using EDrawModeWriteAlpha:-
+
+	- It is rare for client code to need to use this draw mode: see the documentation
+	of SetDrawMode() for more information.
+	- EDrawModeWriteAlpha should only be used with DrawRect(), Clear(), BitBlt(), and BitBltMasked() 
+	with EGray2 mask (and DrawBitmap() and DrawBitmapMasked()). For other draw operations, it is not 
+	supported, and may have unintended effects.
+	- EDrawModeWriteAlpha has the same effect as EDrawModePEN, unless the brush colour has transparency 
+	(DrawRect(), Clear()), or the source bitmap is EColor16MA (and has transparency) (BitBlt(), BitBltMasked())
+	- EDrawModeWriteAlpha has the same effect as EDrawModePEN if the draw mode of the destination does not 
+	support alpha blending. (Blending is only supported in 24bpp and 32bpp colour i.e. EColor16M, EColor16MU, EColor16MA)
+	- In these cases, EDrawModePEN does alpha blending, whereas EDrawModeWriteAlpha means don't do alpha blending.
+
+	@see SetDrawMode()
+	@publishedAll
+	@released
+	*/
+	enum TDrawMode
+		{
+		/** Bitwise ANDs the pen and brush colours with the screen colour. 
+		P=p&s, B=b&s */
+		EDrawModeAND=EAnd,
+		/** Inverts the pen and brush colours before ANDing. P=(~p)&s, 
+		B=(~b)&s */
+		EDrawModeNOTAND=EInvertScreen|EAnd,
+		/** Uses both pen and brush colour as they are. P=p, B=b */
+		EDrawModePEN=EPenmode,
+		/** Inverts the screen colour before ANDing. P=p&(~s), B=b&(~s) */
+		EDrawModeANDNOT=EAnd|EInvertPen,
+		/** Bitwise XORs the pen and brush colours with the screen colour. 
+		P=p^s, B=b^s */
+		EDrawModeXOR=EXor,
+		/** Bitwise ORs the pen and brush colours with the screen colour. 
+		P=p|s, B=b|s */
+		EDrawModeOR=EOr,
+		/** Inverts the screen and pen and brush colours before ANDing. 
+		P=(~p)&(~s), B=(~b)&(~s) */
+		EDrawModeNOTANDNOT=EInvertScreen|EAnd|EInvertPen,
+		/** Inverts the pen and brush colours before XORing. P=(~p)^s, 
+		B=(~b)^s */
+		EDrawModeNOTXOR=EInvertScreen|EXor,
+		/** Inverts the colour of each pixel that is drawn over, (pen and 
+		brush attributes are ignored). P=~s, B=~s */
+		EDrawModeNOTSCREEN=EInvertScreen,
+		/** Inverts the screen colour before ORing. P=p|(~s), 
+		B=b|(~s) */
+		EDrawModeNOTOR=EInvertScreen|EOr,
+		/** Inverts the pen and brush colours. P=~p, B=~b */
+		EDrawModeNOTPEN=EInvertPen|EPenmode,
+		/** Inverts the pen and brush colours before ORing. P=(~p)|s, 
+		B=(~b)|s */
+		EDrawModeORNOT=EOr|EInvertPen,
+		/** Inverts the screen and pen and brush colours before ORing.
+		P=(~p)|(~s), B=(~b)|(~s) */
+		EDrawModeNOTORNOT=EInvertScreen|EOr|EInvertPen,
+		/** Writes alpha information in the source directly into the destination, rather than blending. */
+		EDrawModeWriteAlpha=EWriteAlpha,
+		};
+
+	/** 
+	Pen styles. The screen pattern unit in each definition below describes the 
+	pattern drawn by the line 1 represents a pixel drawn, 0 represents a 
+	pixel that is not affected. 
+	@publishedAll
+	@released
+	*/
+	enum TPenStyle
+		{
+		/** The pen does not draw. Screen pattern unit = 00... */
+		ENullPen,
+		/** A solid line (default). Screen pattern unit = 11... */
+		ESolidPen,
+		/** A dotted line. Screen pattern unit = 1000... */
+		EDottedPen,
+		/** A dashed line. Screen pattern unit = 111000... */
+		EDashedPen,
+		/** A line of alternating dashes and dots. Screen pattern unit = 
+		1111001100... */
+		EDotDashPen,
+		/** A line of alternating single dashes and pairs of dots. Screen 
+		pattern unit = 11110011001100... */
+		EDotDotDashPen
+		};
+
+	/** 
+	Brush styles. 
+	@publishedAll
+	@released
+	*/
+	enum TBrushStyle
+		{
+		/** The brush fill has no effect (default). */
+		ENullBrush,
+		/** The brush fills with a solid single colour, determined by 
+		SetBrushColor() and the drawing mode. */
+		ESolidBrush,
+		/** The brush fills with a selected bitmap pattern, set by 
+		UseBrushPattern(). */
+		EPatternedBrush,
+		/** The brush fills with vertical hatching  lines going from top to 
+		bottom. */
+		EVerticalHatchBrush,
+		/** The brush fills with diagonal hatching lines going from bottom 
+		left to top right. */
+		EForwardDiagonalHatchBrush,
+		/** The brush fills with horizontal hatching  lines going from left 
+		to right. */
+		EHorizontalHatchBrush,
+		/** The brush fills with rearward diagonal hatching lines going from top 
+		left to bottom right. */
+		ERearwardDiagonalHatchBrush,
+		/** The brush fills with horizontal and vertical hatching  lines going 
+		from left to right plus lines going from top to bottom  giving the 
+		effect of a grid of small squares */
+		ESquareCrossHatchBrush,
+		/** The brush fills with forward diagonal and rearward diagonal hatching 
+		lines going from bottom left to top right plus lines going from top left 
+		to bottom right giving the effect of a grid of small diamonds. */
+		EDiamondCrossHatchBrush
+		};
+
+	/** 
+	Rules used to fill self crossing polygons. 
+
+	The filling of a polygon proceeds as follows: for a given point in the 
+	polygon, then
+
+	if the rule is TFillRule::EAlternate (default) and it has an odd winding 
+	number, then fill the surrounding area.
+
+	if the rule is TFillRule::EWinding and it has a winding number greater than 
+	zero, then fill the surrounding area. 
+	@publishedAll
+	@released
+	*/
+	enum TFillRule
+		{
+		/** Only fill areas with odd winding numbers. */
+		EAlternate,
+		/** Fill areas with winding numbers greater than zero. */
+		EWinding
+		};
+
+	/** Parameters to control the drawing of text. */
+	struct TDrawTextParam
+		{
+	public:
+		TDrawTextParam():
+			iDirection(CFont::EHorizontal),
+			iCharJustNum(0),
+			iCharJustExcess(0),
+			iWordJustNum(0),
+			iWordJustExcess(0)
+	/** Reserved for future use. */
+			{}
+	public:
+		/** the direction in which to draw the text. */
+		CFont::TTextDirection iDirection;	
+		/** number of glyph groups to be letterspaced */
+		TInt iCharJustNum;					
+		/** amount of space to be used for letterspacing */
+		TInt iCharJustExcess;				
+		/** number of spaces to be used for wordspacing*/
+		TInt iWordJustNum;					
+		/**  amount of space to be used for wordspacing*/
+		TInt iWordJustExcess;				
+		};
+
+
+	/** Parameters for extended text drawing and measuring. It is used by 
+	CGraphicsContext::DrawTextExtended() to indicate whether text should be 
+	drawn from right-to-left or left-to-right. */
+	struct TDrawTextExtendedParam : public TDrawTextParam
+		{
+	public:
+		/** Constructor. Initialises iParRightToLeft to EFalse. */
+		TDrawTextExtendedParam():
+			iParRightToLeft(EFalse)
+			{}
+	public:
+		/** ETrue if the text direction is right-to-left (for scripts like 
+		Arabic and Hebrew). EFalse if left-to-right. */
+		TBool iParRightToLeft;	
+		};
+	
+	/**
+	Parameters used in drawing text within supplied context.
+	It is used by CGraphicsContext::DrawText() and CGraphicsContext::DrawTextVertical() family of API's
+	to draw text from iStart to iEnd withing the supplied text descriptor.
+	*/
+	class TTextParameters
+		{
+	public:
+		TTextParameters():
+			iStart(0),
+			iEnd(KMaxTInt),
+			iFlags(0)
+				{
+				}
+		TInt iStart;
+		TInt iEnd;
+		TUint16 iFlags;
+		/* Reserved for future use */
+		TAny* iReserved1;
+		TAny* iReserved2;
+		TAny* iReserved3;
+		TAny* iReserved4;
+		};
+public:
+	/** Gets a pointer to the graphics context's graphics device.
+	
+	@return A pointer to the graphics device. */
+	virtual CGraphicsDevice* Device() const=0;
+
+	/** Sets the position of the co-ordinate origin.
+	
+	All subsequent drawing operations are done relative to this origin.
+	
+	@param aPos The origin. The default origin is TPoint(0,0) the top left 
+	corner of the screen. */
+	virtual void SetOrigin(const TPoint& aPos=TPoint(0,0))=0;
+
+	/** Sets the drawing mode. 
+	
+	The way that the pen and brush draw depends on the drawing mode. The drawing 
+	mode affects the colour that is actually drawn, because it defines the way 
+	that the current screen colour logically combines with the current pen colour 
+	and brush colour. There are many drawing modes, each giving different logical 
+	combinations of pen, brush and screen colours. Each mode is produced by ORing 
+	together different combinations of seven drawing mode components.
+	
+	The three most important modes are TDrawMode::EDrawModePEN, TDrawMode::EDrawModeNOTSCREEN 
+	and TDrawMode::EDrawModeXOR. The default drawing mode is TDrawMode::EDrawModePEN.
+	
+	The drawing mode is over-ridden for line and shape drawing functions when 
+	a wide pen line has been selected. It is forced to TDrawMode::EDrawModePEN. 
+	This is to prevent undesired effects at line joins (vertexes).
+	
+	Notes:
+	
+	TDrawMode::EDrawModeAND gives a "colour filter" effect. For example:
+	
+	- ANDing with white gives the original colour
+	- ANDing with black gives black
+	
+	TDrawMode::EDrawModeOR gives a "colour boost" effect. For example:
+	
+	- ORing with black gives the original colour
+	- ORing with white gives white
+	
+	TDrawMode::EDrawModeXOR gives an "Exclusive OR" effect. For example:
+	
+	- white XOR black gives white
+	- white XOR white gives black
+	- black XOR black gives black
+	
+	TDrawMode::EDrawModeWriteAlpha should not normally need to be used by client code. 
+	The following are exceptions:-
+
+	- When a client side EColor16MA bitmap needs to have a transparent background 
+	(because you are intending to blend it onto something else), then you need to set 
+	EDrawModeWriteAlpha to Clear() it.
+	- When you want to BitBlt() with an EColor16MA source bitmap that is opaque everywhere, 
+	then using EDrawModeWriteAlpha is more efficient than EDrawModePEN, because the bitmap 
+	does not need to be blended. 
+
+	Note that if you have a transparent brush or source bitmap and you are drawing to a window, 
+	then it is a defect to use EDrawModeWriteAlpha.
+
+	@param aDrawingMode The drawing mode.
+	@see CGraphicsContext::TDrawMode
+	@see CGraphicsContext::TDrawModeComponents */
+	virtual void SetDrawMode(TDrawMode aDrawingMode)=0;
+
+	/** Sets the clipping rectangle.	 
+	
+	The area of visible drawing depends on the clipping rectangle, any items 
+	that fall outside the extent of the clipping rectangle will not be drawn. 
+	The default clipping rectangle is the full device area.
+	
+	Note that clipping is additive. If a clipping region has been set using SetClippingRegion() 
+	then clipping will be to the intersection of that region and this rectangle.
+		
+	@param aRect The rectangle to be used as the clipping rectangle. Note that 
+	this rectangle is tranformed by the current co-ordinate origin before it is used. 
+	The co-ordinate origin is set using SetOrigin().
+	
+	@see CGraphicsContext::SetClippingRegion() 
+	@see CGraphicsContext::SetOrigin() */
+	virtual void SetClippingRect(const TRect& aRect)=0;
+
+	/** Cancels any clipping rectangle.
+	
+	Clipping thus reverts to the full device area, the default.
+	
+	@see SetClippingRect() */
+	virtual void CancelClippingRect()=0;
+
+	/** Resets the graphics context to its default settings:
+	
+	the drawing mode is TDrawMode::EDrawModePen (pen and brush colours used as 
+	they are)
+	
+	there is no clipping rectangle
+	
+	the pen settings are: black, solid, single pixel size
+	
+	the brush style is null
+	
+	no text font is selected */
+	virtual void Reset()=0;
+
+   /** Sets the device font to be used for text drawing.
+	
+	If the font is already in memory, then that copy is shared.
+	
+	Notes:
+	
+	The CFont* argument must have been previously initialised by calling 
+	MGraphicsDeviceMap::GetNearestFontInTwips() with the required 
+	font-specification. If the CFont* has not been initialised 
+	correctly, and therefore does not point to an available font-bitmap, 
+	then a panic is raised.
+	
+	When the font is no longer required, use DiscardFont() to free up the 
+	memory used. If UseFont() is used again without using DiscardFont() then 
+	the previous font is discarded automatically.
+	
+	If no font has been selected, and an attempt is made to draw text with 
+	DrawText(), then a panic is raised.
+	
+	@param aFont A device font 
+	@see MGraphicsDeviceMap::GetNearestFontInTwips() */
+	virtual void UseFont(const CFont* aFont)=0;
+
+	/** Discards a font.
+	
+	This frees up the memory used, if the font is not being shared.
+	
+	The function can be called when no font is in use. */
+	virtual void DiscardFont()=0;
+
+	/** Sets the underline style.
+	
+	This is applied to all subsequently drawn text.
+	
+	@param aUnderlineStyle The underline style on or off. */
+	virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle)=0;
+
+	/** Sets the strikethrough style.
+	
+	This is applied to all subsequently drawn text.
+	
+	@param aStrikethroughStyle The strikethrough style on or off. */
+	virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle)=0;
+	IMPORT_C static TInt JustificationInPixels(TInt aExcessPixels,TInt aTotalUnits,TInt aFirstUnit,TInt aNumUnits);
+	IMPORT_C static TInt JustificationInPixels(TInt& aExcessPixels,TInt& aTotalUnits);
+
+	/** Adjusts the spaces between words to stretch or squeeze to a certain 
+	width.
+	
+	The function is required by the Text Views API, and is not intended for 
+	regular use by developers.
+	
+	The text line that is to be justified has a certain number of gaps (spaces) 
+	between the words. It also has a distance (in pixels) between the end of 
+	the last word and the actual end of the line (right hand margin, usually). 
+	These excess width pixels are distributed amongst the gaps between the words 
+	to achieve full justification of the text line. Spaces become fat spaces to 
+	keep underlining/strikethrough consistent. Pixels are distributed to the 
+	inter-word gaps starting from the left end of the string. The spacing 
+	between characters in each word remains unchanged.
+	
+	After a call to SetWordJustification(), subsequent calls to either of the 
+	two DrawText() functions are affected until the number of spaces specified 
+	by aNumSpaces is used up.
+	
+	The easiest way to find out the excess width and number of spaces is to call 
+	CFont::MeasureText(). This function can also perform counting, which is 
+	finding how much of some text will fit into a given width.
+	
+	Use CFont::TextCount() to return the excess width.
+	
+	For example, in the string "To be, or not to be", there are five inter-word 
+	gaps. If there are six excess pixels they will be distributed in the 
+	proportion 	2, 1, 1, 1, 1 between the words. If there are nine excess pixels 
+	they will be distributed in the proportion 2, 2, 2, 2, 1 between the words.
+	
+	Notes:
+	
+	If the excess width is zero, then calling SetWordJustification() has no 
+	effect.
+	
+	At first sight it may appear that SetWordJustification() is not required 
+	because you can simply call DrawText() for each word. However, underlined 
+	justified text does not work using this strategy  you get a non-underlined 
+	gap between the space and the beginning of the next word.
+	
+	@param aExcessWidth The width (in pixels) to be distributed between the 
+	specified number of spaces. 
+	@param aNumGaps The number of word spaces (characters with the code U+0020) 
+	over which the change in width is distributed. */
+	virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps)=0;
+
+	/** Sets character justification.
+	
+	This function is required by the Text Views API, and is not intended for 
+	regular use by developers.
+	
+	It affects the strings of text used in the calls to DrawText() that follow, 
+	until the number of characters drawn equals aNumChars.
+	
+	The text line that is to be justified has a certain number of characters
+	this includes the spaces between the words. It also has a distance (in 
+	pixels) between the end of the last word and the actual end of the line 
+	(right hand margin, usually). These excess width pixels are distributed 
+	amongst all the characters, increasing the gaps between them, to achieve 
+	full justification of the text line.
+	
+	Use CFont::TextCount() to return the excess width.
+	
+	Notes:
+	
+	This function is provided to allow simulation of printer fonts on screen. 
+	Due to the fact that fully-scalable fonts are not used before v5, large 
+	printer fonts can be simulated by using the nearest smaller font and 
+	widening it slightly.
+	
+	If the excess width is zero, then calling SetCharJustification() has no 
+	effect.
+	
+	SetCharJustification() is required for WYSIWYG where the layout uses 
+	printer font metrics but screen fonts have to be drawn on the screen. 
+	Because continuously scalable typefaces (c.f. TrueType) are not used 
+	before v5 and because screen fonts are coarser and less numerous in 
+	their variety than the printer fonts, the best matching smaller screen 
+	font must be used with character justification to simulate the printer 
+	font on the screen.
+	
+	There is also a situation where the gaps between characters on screen have 
+	to be reduced with character clipping. The screen font that best matches 
+	the printer font may have the required height, but has characters that are 
+	too wide. A line of text that works on the printer will then be too long 
+	on the screen, unless it is squashed horizontally. The number of pixels 
+	that overlap the end of the screen line must now be removed from the gaps 
+	between the characters, i.e. there is a negative excess width. This 
+	situation is especially important where adding a TAB on screen gives 
+	perfectly acceptable printout, but would push the last character of the 
+	line off the right hand side of the screen.
+	
+	In practice what you do in printer layout mode is:
+	
+	Calculate where the line breaks will come on the printer. To do this you 
+	use a printer font (which in practice means a table of character widths 
+	of the font that the printer will use).
+	
+	Now change to use a screen font that is the closest font which is no taller 
+	that the printer font. In practice it will often be fatter maybe only for 
+	certain characters such as 'i'.
+	
+	You have to recalculate the width of the characters using the screen fonts. 
+	You can do this using CFont::TextWidth() as you have already determined how 
+	many characters will fit on the line.
+	
+	If, in the screen font, the characters are not as wide as the line then you 
+	can just use word justification to expand the line. You would only do this 
+	if the text is to be justified.
+	
+	If, however, the characters are wider than the line then you would use 
+	character justification to clip each character. You would need to do this 
+	even if the line is not justified.
+	
+	Thus, in practice, character justification will only very rarely be used to 
+	expand a line of characters.
+	
+	@param aExcessWidth The excess width (in pixels) to be distributed between 
+	the specified number of characters. It may be positive, in which case the text is 
+	stretched, or negative, in which case it is shrunk.
+	@param aNumChars The number of characters involved. */
+	virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars)=0;
+
+	/** Sets the pen colour.
+	
+	The effective pen colour depends on the drawing mode. The default pen colour 
+	is black.
+	
+	Note:
+	
+	The pen is used to draw lines, the outlines of filled shapes, and text. The 
+	class provides member functions to set the colour of the pen, the style of 
+	line and the line size drawn.
+	
+	@param aColor An RGB colour for the pen. 
+	@see CGraphicsContext::SetDrawMode() */
+	virtual void SetPenColor(const TRgb& aColor)=0;
+
+	/** Sets the line drawing style for the pen. 
+	
+	There are 6 pen styles. If no pen style is set, then the default is 
+	TPenStyle::ESolidPen. To use a pen style, its full context must be given, 
+	e.g. for a null pen:
+	
+	CGraphicsContext::TPenStyle::ENullPen
+	Notes:
+	
+	The pen is used to draw lines, the outlines of filled shapes, and text. 
+	CGraphicsContext member functions are provided to set the colour of the 
+	pen, the style of line and the line size drawn.
+	
+	The TPenStyle::ENullPen style should be used if a border is not required 
+	around a filled shape.
+	
+	Dotted and dashed pen styles have a device dependant implementation, always 
+	give single-pixel size lines on the screen whatever the pen size set 
+	by SetPenSize() and can only be used for straight lines, polylines, 
+	non-rounded rectangles and polygons.
+	
+	The dotted/dashed pattern is continued, without re-starting, for all 
+	consecutively drawn straight lines, i.e.
+	
+	the outlines of rectangles the pattern starts in the top left corner. 
+	It is reset at the end of the function call.
+	
+	the outlines of polygons the pattern starts at the first point. It is 
+	reset at the end of the function call.
+	
+	polylines and straight lines the pattern starts at the first point 
+	initially. Consecutive calls to DrawLine() and/or DrawPolyLine(), whether 
+	the lines are concatenated or not, continue the pattern. It can be reset 
+	by a further call to SetPenStyle() using the same dotted/dashed style 
+	parameter.
+	
+	@param aPenStyle A pen style. 
+	@see CGraphicsContext::TPenStyle */
+	virtual void SetPenStyle(TPenStyle aPenStyle)=0;
+
+	/** Sets the line drawing size for the pen.
+	
+	Lines of size greater than one pixel:
+	
+	are drawn with rounded ends that extend beyond the end points, (as if the 
+	line is drawn using a circular pen tip of the specified size).
+	
+	are always drawn in TDrawMode::EDrawModePEN mode, overriding whatever mode 
+	has been set using SetDrawMode().
+	
+	Notes:
+	
+	The pen is used to draw lines, the outlines of filled shapes, and text. The 
+	class provides member functions to set the colour of the pen, the style of 
+	line and the line size drawn.
+	
+	Wide straight lines and arcs have rounded ends so that concatenated wide 
+	lines have smoothly rounded corners at the vertexes.
+	
+	When lines are made wide, the extra strips of pixels are added equally to 
+	both sides of the line. This works precisely for lines of odd pixel size 
+	(3, 5, 7, etc.). Wide lines of even pixel size, (2, 4, 6, etc.), 
+	have the extra strip of pixels added to the right and/or below the line.
+	
+	Wide outlines of ellipses and wide line arcs are drawn with the pixels 
+	distributed either side of a thin (single pixel wide) true ellipse 
+	constructed in the normal manner. Wide ellipses and arcs of even pixel 
+	size have the extra strip of pixels added to the right and/or below the 
+	curved line. This gives a slight asymmetry to ellipses.
+	
+	If the pen style is dotted or dashed, the size specification is ignored: a 
+	single-pixel wide primitive is drawn, (this is device dependant).
+	
+	A line size of zero is handled as if the pen style had been set to 
+	TPenStyle::ENullPen.
+	
+	@param aSize A line size. The default is 1 pixel. */
+	virtual void SetPenSize(const TSize& aSize)=0;
+
+	/** Sets the brush colour.
+	
+	The effective brush colour depends on the drawing mode.
+	
+	Notes:
+	
+	The brush is used for filling shapes and the background of text boxes. The 
+	brush has colour, style, pattern and pattern origin parameters.
+	
+	If no brush colour has been set, it defaults to white. However the default 
+	brush style is null, so when drawing to a window the default appears to be 
+	the window's background colour.
+	
+	@param aColor An RGB colour for the brush. 
+	@see SetDrawMode() */
+	virtual void SetBrushColor(const TRgb& aColor)=0;
+
+	/**	Sets the brush style.
+
+	Ten brush styles are provided, including six built-in hatching patterns.
+	Note: The brush is used for filling shapes and the background of text boxes.
+	The brush has colour, style, pattern and pattern origin parameters.
+	Note: Use TBrushStyle::ENullBrush to draw the outline of a fillable
+	shape on its own, without filling.
+	Note: If the TBrushStyle::EPatternedBrush style is set, but no bitmap 
+	pattern has been selected using UseBrushPattern(), then the function panics.
+	Note: Hatching lines are done in the current pen colour, set using SetPenColor(). 
+	The hatching pattern starts at the brush origin, set using SetBrushOrigin().
+	@see TBrushStyle::ENullBrush
+	@see TBrushStyle::EPatternedBrush
+	@see UseBrushPattern()
+	@see SetPenColor()
+	@see SetBrushOrigin()
+	@publishedAll
+	@released
+	@param aBrushStyle A brush style. */
+	virtual void SetBrushStyle(TBrushStyle aBrushStyle)=0;
+
+	/** Sets the brush pattern origin.
+	
+	This specifies the top left-hand corner position for the pattern tile around 
+	which copies of the pattern are tiled.
+	
+	The brush pattern may be a built-in style, or a bitmap. To use a bitmap, the 
+	brush must have a pattern set and the brush style must be set to 
+	TBrushStyle::EPatternedBrush.
+	
+	Notes
+	
+	The brush is used for filling shapes and the background of text boxes. The 
+	brush has colour, style, pattern and pattern origin parameters.
+	
+	If SetBrushOrigin() is not used, then the origin defaults to (0,0).
+	
+	This brush origin remains in effect for all fillable shapes drawn 
+	subsequently, until a new brush origin is set. Shapes can thus be 
+	considered as windows onto a continuous pattern field (covering the whole 
+	clipping region of a screen device, or the whole device area of a printer).
+	
+	@param aOrigin An origin point for the brush. The coordinates are relative 
+	to the rectangle to fill, i.e. specify 0,0 to align the pattern flush with 
+	the top and left hand sides of the rectangle.
+	@see SetBrushStyle()
+	@see UseBrushPattern() */
+	virtual void SetBrushOrigin(const TPoint& aOrigin)=0;
+
+	/** Sets the brush pattern to the specified bitmap.
+	
+	For the brush to actually use the bitmap, TBrushStyle::EPatternedBrush must 
+	be used to set the brush style.
+	
+	When the brush pattern is no longer required, use DiscardBrushPattern() to 
+	free up the memory used, if the bitmap is not being shared. 
+	If UseBrushPattern() is used again without using DiscardBrushPattern() 
+	then the previous pattern is discarded automatically.
+	
+	Notes:
+	
+	The brush is used for filling shapes and the background of text boxes. The 
+	brush has colour, style, pattern and pattern origin parameters.
+	
+	When loading a bitmap, the bitmap is checked to see if it is already in 
+	memory. If the bitmap is already there, then that copy is shared.
+	
+	The brush does not need to have a pattern set at all. There are several 
+	built-in hatching patterns which can be selected using SetBrushStyle().
+	
+	@param aBitmap A bitmap pattern for the brush. 
+	@see SetBrushStyle() */
+	virtual void UseBrushPattern(const CFbsBitmap* aBitmap)=0;
+
+	/** Discards a non-built-in brush pattern.
+	
+	This frees up the memory used by the bitmap, if it is not being shared by 
+	another process.
+	
+	Notes:
+	
+	The brush is used for filling shapes and the background of text boxes. The 
+	brush has colour, style, pattern and pattern origin parameters.
+	
+	If DiscardBrushPattern() is used, with no brush pattern set, then there is 
+	no effect. */
+	virtual void DiscardBrushPattern()=0;
+
+
+	/** Sets the drawing point relative to the co-ordinate origin. 
+	
+	A subsequent call to DrawLineTo() or DrawLineBy() uses the new drawing 
+	point as the start point for the line drawn.
+	
+	Notes
+	
+	The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() 
+	also change the internal drawing position to the last point of the drawn 
+	line(s). 
+	
+	The internal drawing position is set to the co-ordinate origin if no drawing 
+	or moving operations have yet taken place.
+	
+	@param aPoint The new internal drawing position. */
+	virtual void MoveTo(const TPoint& aPoint)=0;
+
+	/** Sets the drawing point relative to the current co-ordinates.
+	
+	A subsequent call to DrawLineTo() or DrawLineBy() uses the new drawing point 
+	as the start point for the line drawn.
+	
+	Notes
+	
+	The operations DrawLine(), DrawLineTo(), DrawLineBy() and DrawPolyline() 
+	also change the internal drawing position to the last point of the drawn 
+	line(s). 
+	
+	The internal drawing position is set to the co-ordinate origin if no drawing 
+	or moving operations have yet taken place.
+	
+	@param aVector The amount by which the internal drawing position is to move. */
+	virtual void MoveBy(const TPoint& aVector)=0;
+
+	/** Draws a single point. The point is drawn with the current pen settings 
+	using the current drawing mode.
+	
+	Note:
+	
+	If the pen size is greater than one pixel, a filled circle of the current 
+	pen colour is drawn, with the pen size as the diameter and the plotted point 
+	as the centre. If the pen size is an even number of pixels, the extra pixels 
+	are drawn below and to the right of the centre.
+	
+	@param aPoint The point to be drawn.
+	@see SetPenSize() */
+	virtual void Plot(const TPoint& aPoint)=0;
+
+	/** Draws an arc.
+	
+	The arc is considered a portion of an ellipse. The ellipse is defined by the 
+	TRect argument.
+	
+	The pixels at both the start point and the end point are drawn.
+	
+	The arc itself is the segment of the ellipse drawn in an anti-clockwise 
+	direction from the start point to the end point.
+	
+	Notes:
+	
+	A rectangle is used in the construction of the ellipse of which the arc is 
+	a segment. This rectangle is passed as an argument of type TRect.
+	
+	A wide line arc is drawn with the pixels distributed either side of a true 
+	ellipse, in such a way that the outer edge of the line would touch the edge 
+	of the construction rectangle. In other words, the ellipse used to 
+	construct it is slightly smaller than that for a single pixel line size.
+	
+	If the specified start or end point is at the centre of the ellipse, then 
+	the line that defines the start or end of the arc defaults to one extending 
+	vertically above the centre point.
+	
+	If the start and end point are the same point or are points on the same line 
+	through the ellipse centre then a complete unfilled ellipse is drawn.
+	
+	@param aRect A rectangle in which to draw the ellipse, of which the arc is 
+	a segment. 
+	@param aStart The point defining the start of the arc. It defines one end of 
+	a line from the geometric centre of the ellipse. The point of intersection 
+	between this line and the ellipse defines the start point of the arc.
+	@param aEnd The point defining the end of the arc. It defines one end of a 
+	second line from the geometric centre of the ellipse. The point of 
+	intersection between this line and the ellipse defines the end point of the 
+	arc.
+	@see DrawEllipse() */
+	virtual void DrawArc(const TRect& aRect,const TPoint& aStart,const TPoint& aEnd)=0;
+
+	/** Draws a straight line between two points.
+	
+	@param aPoint1 The point at the start of the line. 
+	@param aPoint2 The point at the end of the line. */
+	virtual void DrawLine(const TPoint& aPoint1,const TPoint& aPoint2)=0;
+
+	/** Draws a straight line from the current drawing point to a specified 
+	point.
+	
+	@param aPoint The point at the end of the line. 
+	@see MoveTo()
+	@see MoveBy() */
+	virtual void DrawLineTo(const TPoint& aPoint)=0;
+
+	/** Draws a straight line relative to the current drawing point, using a 
+	vector.
+	
+	The start point of the line is the current drawing point. The specified 
+	vector 
+	is added to the drawing point to give the end point of the line
+	
+	@param aVector The vector to add to the current internal drawing position, 
+	giving the end point of the line. 
+	@see MoveTo()
+	@see MoveBy() */
+	virtual void DrawLineBy(const TPoint& aVector)=0;
+
+	/** Draws a polyline from a set of points in an array.
+	
+	A polyline is a series of concatenated straight lines joining a set of 
+	points.
+	
+	@param aPointList An array containing the points on the polyline. */
+	virtual void DrawPolyLine(const CArrayFix<TPoint>* aPointList)=0;
+
+	/** Draws a polyline from a set of points in a list.
+	
+	A polyline is a series of concatenated straight lines joining a set of 
+	points.
+	
+	@param aPointList Pointer to a set of points on the polyline.
+	@param aNumPoints Number of points in the list. */
+	virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints)=0;
+
+	/** Draws and fills a pie slice.
+	
+	The pie slice is an area bounded by:
+	
+	the arc of an ellipse drawn in an anticlockwise direction from the start 
+	point to the end point
+	
+	the straight line drawn to the start point from the geometric centre of the 
+	ellipse.
+	
+	the straight line to the end point from the geometric centre of the ellipse.
+	
+	Notes:
+	
+	A rectangle is used in the construction of the pie slice. This rectangle is 
+	passed as an argument of type TRect. The curved edge of the pie slice is an 
+	arc of an ellipse constructed within the rectangle.
+	
+	The line drawn by the pen goes inside the specified rectangle.
+	
+	The pixels at the end point of the arc are not drawn.
+	
+	A wide line edged pie slice has the arc drawn with the pixels distributed 
+	either side of a true ellipse. This is done in such a way that the outer 
+	edge of the line touches the edge of the construction rectangle. In other 
+	words, the ellipse used to construct it is slightly smaller than that for 
+	a single pixel line size.
+	
+	If the specified start or end point is at the centre of the ellipse, then 
+	the line that defines the start or end of the arc defaults to one extending 
+	vertically above the centre point.
+	
+	If the start and end point are the same point or are points on the same line 
+	through the ellipse centre then a complete filled ellipse is drawn. A line 
+	is also drawn from the edge to the ellipse centre.
+	
+	@param aRect A rectangle in which to draw the ellipse bounding the pie slice. 
+	@param aStart A point defining the start of the arc bounding the pie slice. 
+	It defines one end of a line from the geometrical centre of the ellipse. The 
+	point of intersection between this line and the ellipse defines the start 
+	point of the arc.
+	@param aEnd A point to define the end of the arc bounding the pie slice. It 
+	defines one end of a second line from the geometrical centre of the ellipse. 
+	The point of intersection between this line and the ellipse defines the end 
+	point of the arc. */
+	virtual void DrawPie(const TRect& aRect,const TPoint& aStart,const TPoint& aEnd)=0;
+
+	/** Draws and fills an ellipse.
+	
+	The ellipse is drawn inside the rectangle defined by the TRect argument. Any 
+	rectangle that has odd pixel dimensions, has the bottom right corner trimmed 
+	to give even pixel dimensions before the ellipse is constructed.
+	
+	Note:
+	
+	A wide outline ellipse is drawn with the pixels distributed either side of 
+	a true ellipse, in such a way that the outer edge of the line touches the 
+	edge of the construction rectangle. In other words, the ellipse used to 
+	construct it is smaller than that for a single pixel line size.
+	
+	@param aRect The rectangle in which the ellipse is drawn. */
+	virtual void DrawEllipse(const TRect& aRect)=0;
+
+	/** Draws and fills a rectangle.
+	
+	@param aRect The rectangle to be drawn. */
+	virtual void DrawRect(const TRect& aRect)=0;
+
+	/** Draws and fills a rectangle with rounded corners.
+	
+	The rounded corners are each constructed as an arc of an ellipse.
+	
+	The line drawn by the pen, if any, goes inside the specified rectangle.
+	
+	Notes:
+	
+	Dotted and dashed pen styles cannot be used for the outline of a rounded 
+	rectangle.
+	
+	If either corner size dimension is greater than half the corresponding 
+	rectangle length, the corner size dimension is reduced to half the 
+	rectangle size.
+	
+	@param aRect The rectangle to be drawn. 
+	@param aCornerSize The dimensions of each corner. 
+	@see DrawArc() */
+	virtual void DrawRoundRect(const TRect& aRect,const TSize& aCornerSize)=0;
+
+	/** Draws and fills a polygon defined using an array of points.
+	
+	The first point in the array defines the start of the first side of the 
+	polygon. The second point defines the second vertex (the end point of the 
+	first side and the start point of the second side).
+	
+	The final side of the polygon is drawn using the last point from the array, 
+	and the line is drawn to the start point of the first side.
+	
+	Self-crossing polygons are filled according to the specified fill rule.
+	
+	@param aPointList An array of points, specifying the vertices of the polygon.
+	@param aFillRule The fill rule. By default, this is TFillRule::EAlternate. 
+	@return KErrNone, if successful; otherwise, another of the system-wide error 
+	codes. */
+	virtual TInt DrawPolygon(const CArrayFix<TPoint>* aPointList,TFillRule aFillRule=EAlternate)=0;
+
+	/** Draws and fills a polygon defined using a list of points.
+	
+	The first point in the list defines the start of the first side of the 
+	polygon. The second point defines the second vertex (the end point of the 
+	first side and the start point of the second side).
+	
+	The final side of the polygon is drawn using the last point from the list, 
+	and the line is drawn to the start point of the first side.
+	
+	Self-crossing polygons are filled according to the specified fill rule.
+	
+	@param aPointList Pointer to list of points, specifying the vertices of the 
+	polygon.
+	@param aNumPoints The number of points in the list.
+	@param aFillRule The fill rule. By default this is TFillRule::EAlternate. 
+	@return KErrNone, if successful; otherwise, another of the system-wide error 
+	codes. */
+	virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate)=0;
+
+	/** Draws a bitmap at the specified point.
+	
+	The point specifies the top left hand corner of the bitmap. The bitmap is 
+	compressed or stretched based on its internally stored size in twips.
+	
+	Notes:
+	
+	This member function uses the bitmap's size in twips and does a 
+	stretch/compress blit using a linear DDA.
+	
+	As this function scales the bitmap, it is unavoidably slow. Therefore, where 
+	possible, use CBitmapContext::BitBlt() instead. If the bitmap has to be 
+	scaled, consider creating another bitmap along with an CFbsBitmapDevice etc, 
+	doing DrawBitmap() once and using BitBlt() subsequently.
+	
+	Note that all bitmaps are clipped to the device boundaries.
+	
+	@param aTopLeft The point where the top left pixel of the bitmap is to be 
+	drawn 
+	@param aSource A source bitmap 
+	@see TLinearDDA */
+	virtual void DrawBitmap(const TPoint& aTopLeft,const CFbsBitmap* aSource)=0;
+
+	/** Draws a bitmap to fit a given rectangle. 
+	
+	The bitmap is compressed or stretched based on its internally stored size 
+	in pixels.
+	
+	Notes:
+	
+	This member function uses the bitmap's size in pixels and does a 
+	stretch/compress blit using a linear DDA.
+	
+	As this function scales the bitmap, it is unavoidably slow. Therefore, 
+	where possible, use CBitmapContext::BitBlt() instead. If the bitmap has 
+	to be scaled, consider creating another bitmap along with an 
+	CFbsBitmapDevice etc., doing DrawBitmap() once and using BitBlt() 
+	subsequently.
+	
+	Note that all bitmaps are clipped to the device boundaries.
+	
+	@param aDestRect The rectangle within which the bitmap is to be drawn. 
+	@param aSource A source bitmap. 
+	@see TLinearDDA */
+	virtual void DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource)=0;
+
+	/** Draws a specified rectangle of a source bitmap to fit into a given 
+	destination rectangle.
+	
+	Notes:
+	
+	This member function uses rectangle sizes in pixels and does a 
+	stretch/compress blit using a linear DDA.
+	
+	As this function scales the bitmap, it is unavoidably slow. Therefore, 
+	where possible, use CBitmapContext::BitBlt() instead. If the bitmap has 
+	to be scaled, consider creating another bitmap along with an 
+	CFbsBitmapDevice etc., doing DrawBitmap() once and using BitBlt() 
+	subsequently.
+	
+	Note that all bitmaps are clipped to the device boundaries.
+	
+	@param aDestRect The rectangle within which the bitmap is to be drawn. 
+	@param aSource A source bitmap. 
+	@param aSourceRect The rectangle in the source bitmap that is copied to the 
+	destination rectangle. 
+	@see TLinearDDA */
+	virtual void DrawBitmap(const TRect& aDestRect,const CFbsBitmap* aSource,const TRect& aSourceRect)=0;
+
+	/** Draws a specified rectangle of a source bitmap to fit into a given rectangle using a given mask.
+
+	Notes:
+	
+	  This member function uses rectangle sizes in pixels and does a 
+	stretch/compress blit using a linear DDA.
+	
+	
+	@param aDestRect The rectangle within which the bitmap is to be drawn. 
+	@param aBitmap The source bitmap
+	@param aSourceRect The rectangle in the source bitmap that is to be drawn
+	@param aMaskBitmap The mask to be applied to the source bitmap while drawing
+	@param aInvertMask Flag to indicate if the mask should be inverted.
+	*/
+	virtual void DrawBitmapMasked(const TRect& aDestRect,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask)=0;
+
+	/** Draws a specified rectangle from a wserv bitmap and its mask into 
+	another rectangle.
+
+	The function compresses/stretches the specified rectangle from the bitmap 
+	to fit the destination rectangle. 
+	The mask bitmap can be used as either a positive or negative mask. Masked 
+	pixels are not mapped to the destination rectangle.
+
+	A black and white (binary) mask bitmap is used. With aInvertMask=EFalse, black 
+	pixels in the mask bitmap stop corresponding pixels in the source bitmap from 
+	being transferred to the destination rectangle. With aInvertMask=ETrue, white 
+	pixels in the mask bitmap stop corresponding pixels in the source bitmap from 
+	being transferred to the destination rectangle.
+
+	Note: this member function uses rectangle sizes in pixels and does a stretch/compress 
+	blit using a linear DDA.
+
+	@param aDestRect The rectangle within which the masked bitmap is to be drawn. 
+	@param aBitmap A source wserv bitmap. 
+	@param aSourceRect The rectangle in the source bitmap that is copied to the 
+	destination rectangle.
+	@param aMaskBitmap A mask wserv bitmap. 
+	@param aInvertMask If false, a source pixel that is masked by a black pixel 
+	is not transferred to the destination rectangle. If true, then a source pixel 
+	that is masked by a white pixel is not transferred to the destination rectangle. */
+	virtual void DrawBitmapMasked(const TRect& aDestRect,const CWsBitmap* aBitmap,const TRect& aSourceRect,const CWsBitmap* aMaskBitmap,TBool aInvertMask)=0;
+
+	/** Draws text without a surrounding box. 
+	
+	The text baseline is aligned with the y co-ordinate of the specified point, 
+	and the left end of the text is aligned with the x co-ordinate of the 
+	specified point.
+	
+	Note:
+	
+	Text drawing is done with the pen, and is subject to the pen colour. The 
+	effective text colour also depends on the drawing mode. The size and style 
+	of the text depends on the font used. The layout of the text depends on the 
+	justification mode set.
+	
+	@param aText The text string to be drawn. 
+	@param aPosition A point specifying the position of the left end of the text. */
+	virtual void DrawText(const TDesC& aText,const TPoint& aPosition) = 0;
+
+	/** Draws text inside a box.
+	
+	The surrounding box is filled with the current brush colour (not a pattern) 
+	and is drawn without any outline. The effective box colour depends on the 
+	drawing mode - if a brush colour has not been set then the brush defaults 
+	to white. The brush may be set to TBrushStyle::ENullBrush if text 
+	positioning relative to a box is required, but the box should not be filled.
+	
+	The font used is that set by UseFont(). If no font is in use then a panic 
+	occurs.
+	
+	The alignment of the text within the box can be specified.
+	
+	Text drawn within a box is also clipped to that box. Unless you intend to 
+	clip the top off the text, aBaselineOffset should be greater than or equal 
+	to the ascent of the current font.
+	
+	Offsets:
+	
+	If the offset is negative, zero, or less than font height this is handled 
+	as would be expected, i.e. no text will be seen in the box in the first two 
+	instances, and the top of the text will be clipped in the latter case.
+	
+	Margins:
+	
+	For the drawing of right-aligned text, aLeftMargin indicates the margin from 
+	the right of aBox - where a positive value results in a leftwards offset. 
+	
+	Negative margins can be used to display portions of the text string clipped 
+	by the box. A negative margin for left aligned text would clip the start of 
+	the text string. Similarly, a negative margin for right aligned text would 
+	clip the end of the text string.
+	
+	If the margin is greater than the width of the box then no text will be 
+	visible.
+	
+	The margin is still honoured for centred text - centred text will not be 
+	centred in the box, unless the margin is zero.
+	
+	Note:
+	
+	Text drawing is done with the pen, and is thus subject to the pen colour. 
+	The effective text colour also depends on the drawing mode. The size and 
+	style of the text depends on the used font. The layout of the text depends 
+	on the justification mode set.
+	
+	@param aText The text string to be drawn. 
+	@param aBox The box to draw the text in. 
+	@param aBaselineOffset An offset from the top of the box to the text 
+	baseline. 
+	@param aAlignment The text alignment mode default is left aligned. 
+	@param aLeftMargin The left margin for left-aligned text, or the right 
+	margin 
+	for right-aligned text default is zero. */
+	virtual void DrawText(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TTextAlign aAlignment = ELeft,
+		TInt aLeftMargin = 0) = 0;
+	IMPORT_C virtual void DrawText(const TDesC& aText,const TPoint& aPosition,const TDrawTextParam& aParam);
+	IMPORT_C virtual void Reserved();
+	IMPORT_C TInt DrawTextExtended(const TDesC& aText,const TPoint& aPosition,const TDrawTextExtendedParam& aParam);
+							
+	/** Maps pixels in the specified rectangle.
+	The function tries to match the colour of a pixel with one of the RGB values 
+	in an array of RGB pairs. If there is a match, the colour is changed to the 
+	value specified in the other RGB in the RGB pair.
+	@param aRect The rectangle in which pixels are to be mapped.
+	@param aColors A pointer to a set of RGB pairs. 
+	@param aNumPairs The number of pairs 
+	@param aMapForwards ETrue, mapping is done from the first RGB to the second 
+	RGB in the pair; EFalse, mapping is done from the second RGB to the first 
+	RGB in the pair. */	
+	virtual void MapColors(const TRect &aRect,const TRgb *aColors,TInt aNumPairs,TBool aMapForwards) = 0;
+	
+	/** Sets the clipping region, any items that fall outside the extent of the clipping 
+	region will not be drawn.
+	
+	Note that clipping is additive. If a clipping rectangle has been set using SetClippingRect() 
+	then clipping will be to the intersection of that rectangle and this region.
+	
+	@param aRegion The new clipping region. Note that clipping region co-ordinates are
+	used as absolute co-ordinates, they are not transformed by the current co-ordinate 
+	origin before use (as occurs in SetClippingRect()).
+	 
+	@return KErrNone if successful; KErrArgument if the TRegion is not valid; KErrNoMemory if there is insufficient memory.
+	
+	@see CGraphicsContext::CancelClippingRegion() 
+	@see CGraphicsContext::SetClippingRect() */		
+	virtual TInt SetClippingRegion(const TRegion &aRegion) = 0;
+	
+	/** Cancels the current clipping region. 
+	@see CGraphicsContext::SetClippingRegion()*/
+	virtual void CancelClippingRegion() = 0;
+	
+	/** Draws vertical text in the specified direction.
+	@param aText The text to be drawn. 
+	@param aPos Point of origin of the text baseline. 
+	@param aUp Direction. ETrue for up, EFalse for down. */
+	virtual void DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp) = 0;
+	
+	/** Draws text vertically in the specified direction, within a box of the specified size.
+	@param aText The text to be drawn. 
+	@param aBox The bounding box within which the text should be drawn, and which it is clipped to.
+	@param aBaselineOffset The height of the top of the characters from their text baseline. 
+	@param aUp The direction. ETrue for up, EFalse for down.
+	@param aVert The text alignment. 
+	@param aMargin The margin. */	
+	virtual void DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0) = 0;
+	
+	IMPORT_C TInt GetUnderlineMetrics(TInt& aTop,TInt& aBottom);
+
+	/** Set the font's shadow colour
+	@param aShadowColor Shadow colour to be set.
+	@return KErrNone, if successful; otherwise, another of the system-wide errors. */
+	IMPORT_C TInt SetShadowColor(const TRgb& aShadowColor);
+
+	/** Get the font's shadow colour
+	@param aShadowColor Shadow colour of the font returned by the funtion.
+	@return KErrNone, if successful; otherwise, another of the system-wide errors. */
+	IMPORT_C TInt GetShadowColor(TRgb& aShadowColor);
+
+	/** Determine if the Gc is a CFbsBitGc
+	@return ETrue, if the Gc is a CFbsBitGc, EFalse otherwise 
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases.
+	*/
+	IMPORT_C TBool IsFbsBitGc() const;
+
+	IMPORT_C void DrawText(const TDesC& aText,const TTextParameters* iParam,const TPoint& aPosition);
+	IMPORT_C void DrawText(const TDesC& aText,const TTextParameters* iParam,const TRect& aBox,TInt aBaselineOffset,TTextAlign aHrz=ELeft,TInt aMargin=0);
+	IMPORT_C void DrawText(const TDesC& aText,const TTextParameters* iParam,const TPoint& aPosition,const TDrawTextParam& aParam);
+
+	IMPORT_C void DrawTextVertical(const TDesC& aText,const TTextParameters* iParam,const TPoint& aPos,TBool aUp);
+	IMPORT_C void DrawTextVertical(const TDesC& aText,const TTextParameters* iParam,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);
+	
+	IMPORT_C TInt DrawTextExtended(const TDesC& aText,const TTextParameters* iParam,const TPoint& aPosition,const TDrawTextExtendedParam& aParam);
+	
+protected:
+
+	/**
+	An APIExtension method to allow the addition of new APIs to retain compatibility 
+	with previous versions of gdi.dll
+	@param aOutput is for output
+	@param aInput is for input
+	@see CGraphicsContext
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases.
+	*/
+	IMPORT_C virtual TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);	
+	
+	/**
+	A reserved virtual function for future use.
+	*/
+	IMPORT_C virtual void Reserved_CGraphicsContext_2();		
+	};
+
+
+/** An abstract, device-independent, interface to bitmapped graphics contexts.
+
+This holds the setting used to draw to a CBitmapDevice.
+
+The default settings of a CBitmapContext object immediately after construction 
+are:
+
+drawing mode is EDrawModePen (pen and brush colours used as they are)
+
+no clipping rectangle
+
+pen settings are: black, solid, single pixel width
+
+brush style is null
+
+no text font selected
+
+The classes CFbsBitGc and CWindowGc are derived from this class.
+
+@see CFbsBitGc 
+@publishedAll
+@released
+*/
+class CBitmapContext : public CGraphicsContext
+	{
+public:
+	/** Clears the whole bitmap.
+	
+	The cleared area is filled with the current brush colour.
+	
+	This pure virtual function is implemented in derived classes. */
+	virtual void Clear()=0;
+
+	/** Clears a rectangular area of a bitmap.
+	
+	The cleared area is filled with the current brush colour.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aRect The rectangle to clear. */
+	virtual void Clear(const TRect& aRect)=0;
+
+	/** Copies a rectangle.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aOffset The offset from the top left corner of the rectangle to be 
+	copied to the top left corner of the copy.
+	@param aRect The rectangular area to be copied. */
+	virtual void CopyRect(const TPoint& aOffset,const TRect& aRect)=0;
+
+	/** Performs a bitmap block transfer.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aPoint The destination for the top left corner of the transferred bitmap. 
+	It is relative to the top left corner of the destination bitmap, which may be the screen.
+	@param aBitmap A memory-resident bitmap. */
+	virtual void BitBlt(const TPoint& aPoint,const CFbsBitmap* aBitmap)=0;
+
+	/** Performs a bitmap block transfer of a rectangular piece of a bitmap.
+	
+	If the specified rectangle is larger than the bitmap then the bitmap is 
+	padded with white.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aPoint The destination for the top left corner of the transferred bitmap.
+	It is relative to the top left corner of the destination bitmap, which may be the screen.
+	
+	@param aBitmap A memory-resident bitmap 
+	@param aRect A rectangle defining the portion of the bitmap to transfer. 
+	Its coordinates are relative to the top left corner of the source bitmap.   */
+	virtual void BitBlt(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aRect)=0;
+
+	/** Performs a masked bitmap block transfer.
+	
+	The mask bitmap can be used as either a positive or negative mask. Masked 
+	pixels are not mapped to the destination rectangle.
+	
+	This function uses either a black and white (binary) mask bitmap, or if 
+	aMaskBitmap's display mode is EGray256, alpha blending is used. Use of 
+	any other mode may result in unpredictable results
+	
+	With aInvertMask=EFalse, black pixels in the mask bitmap stop corresponding 
+	pixels in the source bitmap from being transferred to the destination rectangle. 
+	With aInvertMask=ETrue, white pixels in the mask bitmap stop corresponding 
+	pixels in the source bitmap from being transferred to the destination 
+	rectangle.
+	
+	Note that if the mask bitmap is smaller than the source bitmap, then it is 
+	tiled across the bitmap. Note that the mask is applied before the piece of 
+	the bitmap is defined - the mask is tiled relative to the top left of the 
+	original source bitmap rather than the top left of the bitmap piece.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aPoint The destination for the top left corner of the transferred bitmap. 
+	It is relative to the top left corner of the destination bitmap, which may be the screen. 
+	@param aBitmap A memory-resident source bitmap. 
+	@param aSourceRect A rectangle defining the piece of the bitmap to be drawn, 
+	with co-ordinates relative to the top left corner of the bitmap. 
+	@param aMaskBitmap A mask bitmap 
+	@param aInvertMask If  EFalse, a source pixel that is masked by a black pixel 
+	is not transferred to the destination rectangle. If ETrue, then a source 
+	pixel that is masked by a white pixel is not transferred to the destination 
+	rectangle. */
+	virtual void BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask)=0;
+
+	/** Sets whether the graphics context is faded.
+	
+	@param aFaded ETrue to fade the GC; EFalse to unfade it. */
+	virtual void SetFaded(TBool aFaded)=0;
+
+	/** Sets the fading parameters.
+	
+	This function allows you to override the map used when drawing with a faded 
+	graphics context (GC). However if you draw to a faded window with a faded 
+	GC, then fading on the GC is ignored and the fading of the window is used.
+	
+	Fading is used to change the colour of a window to make other windows stand 
+	out. Fading can either make a faded window closer to white or closer to 
+	black.
+	
+	Fading re-maps colours in the faded GC to fall between the specified black 
+	and white map values. If aBlackMap=0 and aWhiteMap=255 then the colours are 
+	mapped unchanged. As the values converge the colours are mapped to a smaller 
+	range - so the differences between colours in the faded GC decrease. If 
+	the values are reversed then the colours are inverted (i.e. where the GC 
+	would be black, it is now white). 
+	
+	@param aBlackMap Black map fading parameter. Unfaded this is 0. 
+	@param aWhiteMap White map fading parameter. Unfaded this is 255. */
+	virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap)=0;
+
+	/**
+	Performs an alpha blending of the source data, aSrcBmp, with the CBitmapContext, using
+	the data from aAlphaBmp as an alpha blending factor.
+	The formula used is:
+	(S * A + W * (255 - A)) / 255, where:
+	- S - a pixel from aSrcBmp;
+	- W - a pixel from the window;
+	- A - a pixel from aAlphaBmp;
+	The contents of source and alpha bitmap are preserved.
+	The calculated alpha blended pixels are written to the destination CBitmapContext.
+	@param aDestPt Position in the target the result should be drawn to.
+	@param aSrcBmp A pointer to the source bitmap.
+	@param aSrcRect The part of the source bitmap that should be used.
+	@param aAlphaBmp A pointer to the bitmap used as an alpha blending factor.
+	@param aAlphaPt Position of the first pixel in the alpha bitmap that should be used as a source 
+	                for the alpha blending. The size of the area is the same as the 
+	                source bitmap area - aSrcRect parameter.*/	
+	
+	virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt) = 0;	
+	
+	/**
+	The method performs an alpha blending of the source data, aSrcBmp, with the CBitmapContext, using
+	the data from aAlphaBmp as an alpha blending factor.
+	For information on how this function works, see the other overload.
+	@param aDestPt Position in the target the result should be drawn to.
+	@param aSrcBmp A pointer to the source bitmap.
+	@param aSrcRect The part of the source bitmap that should be used.
+	@param aAlphaBmp A pointer to the bitmap used as an alpha blending factor.
+	@param aAlphaPt Position of the first pixel in the alpha bitmap that should be used as a source 
+	                for the alpha blending. The size of the area is the same as the 
+	                source bitmap area - aSrcRect parameter.*/
+	virtual	TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp,	const TRect& aSrcRect, const CWsBitmap* aAlphaBmp, const TPoint& aAlphaPt) = 0;
+	
+protected:
+
+	/*
+	Implementations from CGraphicsContext
+	@see CGraphicsContext::APIExtension(TUid, TAny*&, TAny*)
+	*/
+	IMPORT_C TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);	
+	/*
+	Implementations from CGraphicsContext
+	@see CGraphicsContext::Reserved_CGraphicsContext_2()
+	*/
+	IMPORT_C void Reserved_CGraphicsContext_2();
+
+	IMPORT_C virtual void Reserved_CBitmapContext_1();
+	IMPORT_C virtual void Reserved_CBitmapContext_2();
+	IMPORT_C virtual void Reserved_CBitmapContext_3();
+	};
+
+/** Defines an abstract interface for the capabilities and attributes of a 
+bitmapped graphics device.
+
+The class specialises the graphics device interface CGraphicsDevice for bitmaps 
+graphics. The Window Server Client-Side API provides one implementation of 
+the interface, CWsScreenDevice, for screen drawing. Another implementation, 
+CFbsBitmapDevice, is used for drawing to in-memory bitmaps. A third, 
+CFbsScreenDevice, is used (rarely) to access the screen directly, without the 
+mediation of the window server. 
+@publishedAll
+@released
+*/
+class CBitmapDevice : public CGraphicsDevice
+	{
+public:
+	/** Gets the RGB colour of an individual pixel on a bitmapped graphics 
+	device. 
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aColor On return, should contain the RGB colour of the pixel. 
+	@param aPixel The (x,y) co-ordinates of the pixel. The top left pixel is 
+	(0,0). */
+	virtual void GetPixel(TRgb& aColor,const TPoint& aPixel) const=0;
+
+	/** Copies a scanline into a buffer.
+	
+	The pixels are converted from the display mode format on the bitmapped 
+	graphics device to the format of the specified device display mode.
+	
+	By specifying the start pixel and the number of pixels, either the whole or 
+	a portion of a bitmapped graphics device pixel row may be copied.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aBuf An 8 bit modifiable descriptor buffer into which pixels are 
+	copied; it must be sufficiently large to store all the scanline pixels. 
+	@param aStartPixel The (x,y) co-ordinates of the first pixel of the bitmap 
+	scanline to be put into the buffer. 
+	@param aLength The number of pixels to put into the buffer. 
+	@param aDispMode The display mode into which to convert the pixels. */
+	virtual void GetScanLine(TDes8& aBuf,const TPoint& aStartPixel,TInt aLength,TDisplayMode aDispMode) const=0;
+
+	/** Adds a font file to the device's typeface store. The specified font
+	file must be accessible to any process, i.e. not located inside an
+	application's private directory.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aName The name of the font file. 
+	@param aId On return, contains an ID for the font file. 
+	@return KErrNone, if successful; otherwise, another of the system-wide error 
+	codes. */
+	virtual TInt AddFile(const TDesC& aName,TInt& aId)=0;
+
+	/** Removes a font file from the font store.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aId The ID of the font file to be removed. The default is 0. */
+	virtual void RemoveFile(TInt aId=0)=0;
+
+	/**
+	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 GetNearestFontToDesignHeightInPixels() 
+	yielding (virtually) the same result. However clients are strongly encouraged to use the new
+	@c GetNearestFontToMaxHeightInPixels() function instead. This will guarantee that every 
+	character within any given text string will fit within the given amount of pixels, 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 GetNearestFontToDesignHeightInPixels
+	*/
+	virtual TInt GetNearestFontInPixels(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 GetNearestFontInPixels() yielding (virtually) the 
+	same result. However clients are strongly encouraged to use the new
+	@c GetNearestFontToMaxHeightInPixels() function instead. This will guarantee that every 
+	character within any given text string will fit within the given amount of pixels, 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 GetNearestFontToDesignHeightInPixels(
+		CFont*& /*aFont*/, const TFontSpec& /*aFontSpec*/) { return KErrNotSupported; }
+
+	/**
+	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.
+	This overrides the height specified in aFontSpec.
+	@return KErrNone if successful; a system-wide error code otherwise.
+	@publishedAll
+	@released
+	*/
+	virtual TInt GetNearestFontToMaxHeightInPixels(
+		CFont*& /*aFont*/, const TFontSpec& /*aFontSpec*/, TInt /*aMaxHeight*/) { return KErrNotSupported; }
+
+	/** Gets the height, in pixels, of the specified typeface at one of its 
+	defined heights.
+	
+	The typeface is identified by by an index. For a given typeface, there are 
+	a discrete number of heights; the specific height is also identified by an 
+	index.
+	
+	The value returned is rounded up or down to the nearest font height in 
+	pixels.
+	
+	This pure virtual function is implemented in derived classes.
+	
+	@param aTypefaceIndex A typeface index number, in the range: 0 to 
+	(NumTypefaces() - 1). 
+	@param aHeightIndex A font height index number, in the range: 0 to 
+	(iNumHeights - 1) where iNumHeights is a public data member of the 
+	TTypefaceSupport object returned by TypefaceSupport(). 
+	@return The height of the font, in pixels.
+	@see TTypefaceSupport
+	@see CGraphicsDevice::NumTypefaces()
+	@see CGraphicsDevice::TypefaceSupport() */
+	virtual TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const=0;
+    inline TInt CreateBitmapContext(CBitmapContext*& aGC);
+	};
+
+/** A set of margins used for cropping a picture. 
+
+Margins are specified in twips or pixels. 
+@publishedAll
+@released
+*/
+class TMargins
+    {
+public:
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C TBool operator==(const TMargins& aMargins) const;
+	IMPORT_C TBool operator!=(const TMargins& aMargins) const;
+public:
+	/** Left margin, (in twips or pixels). */
+	TInt iLeft;
+	/** Right margin, (in twips or pixels). */
+	TInt iRight;
+	/** Top margin, (in twips or pixels). */
+    TInt iTop;
+	/** Bottom margin, (in twips or pixels). */
+	TInt iBottom;
+	};
+
+/** Picture capabilities.
+
+These include the types of scaling that can be applied to a picture, and whether 
+or not it is croppable. 
+@publishedAll
+@released
+*/
+class TPictureCapability
+	{
+public:
+	/** Scaling types. */
+	enum TScalingType
+		{
+		/** The picture is not scalable. */
+		ENotScaleable,
+		/** The picture is fully scalable. */
+		EFullyScaleable,
+		/** The picture is scalable to any size, as long as its aspect ratio 
+		(the ratio of its height to its width) remains constant. */
+		EScaleableMaintainingAspectRatio
+		};
+public:
+	inline TPictureCapability(TScalingType aScalingType,TBool aCroppable);
+public:
+	/** Whether or not the picture is croppable. */
+	TScalingType iScalingType;
+	/** Scaling type. */
+	TBool iIsCroppable;
+	};
+
+/** Abstract base class for: drawing a picture to a graphics context, storing 
+and restoring the picture. 
+
+The class defines the protocol for a number of concrete picture classes. Its 
+main role is to support glass doors used in object embedding.
+
+The class provides a protocol for the provision of scaling and cropping 
+functions by derived classes, together with default implementations.
+
+Its main function is Draw(), which draws the picture onto the graphics context 
+at a particular point. It also has two important pure virtual functions: 
+ExternalizeL() and GetOriginalSizeInTwips().
+
+A picture has both an original representation and an on-screen representation. 
+The original representation has a size in twips, and can somehow be drawn. 
+The on-screen representation is assumed to be drawn under the control of an 
+application which may wish to re-size or scale the original in some way, to 
+crop it at the edges, and/or to ensure it fits within a particular defined 
+area on the screen.
+
+The class provides several functions that allow an application to set scaling 
+and cropping before invoking the Draw() function to draw the picture on-screen. 
+It is up to the internal workings of the function to determine the order of 
+application cropping and scaling. 
+@publishedAll
+@released
+*/
+class CPicture : public CBase
+    {
+public:
+	/** Options for detaching pictures from stores. Used by DetachFromStoreL(). */
+	enum TDetach
+		{
+		/** Internalise all data that is required to fully store the picture 
+		later; null any references to containing stores. */
+		EDetachFull,
+		/** Internalise enough information to draw the picture (and no more); 
+		null any references to containing stores. */
+		EDetachDraw
+		};
+public:
+	IMPORT_C virtual ~CPicture();
+	/** Draws a picture.
+	
+	@param aGc The graphics context. 
+	@param aTopLeft The co-ordinates where the top left corner pixel of the 
+	picture should be placed. Note that whether this is actually drawn depends 
+	on the clipping area defined.
+	@param aClipRect A clipping rectangle that defines the area to which the 
+	function should draw. An implementation should never draw outside this 
+	rectangle. Note that the graphics context may also have a clipping rectangle 
+	set on it. 
+	@param aMap The device map for the graphics device. The implementation 
+	should use this to find the scaling to apply to the picture. */
+	virtual void Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,MGraphicsDeviceMap* aMap) const=0;
+	IMPORT_C virtual TStreamId StoreL(CStreamStore& aStore) const; // assumes no sub streams
+	virtual void DetachFromStoreL(TDetach /*aDegree*/=EDetachFull) {}
+
+	/** Externalises the picture to a stream.
+	
+	The presence of this function means that the standard templated stream 
+	operator<<() is available to externalise objects of this class.
+	
+	A derived class must supply an implementation of this function.
+	
+	@param aStream The write stream. */
+	virtual void ExternalizeL(RWriteStream& aStream) const =0;
+
+	/** Gets the pictur's original size, in twips.
+	
+	@param aSize The size of the picture, in twips */
+	virtual void GetOriginalSizeInTwips(TSize& aSize) const =0;
+	IMPORT_C virtual void SetScaleFactor(TInt aScaleFactorWidth,TInt aScaleFactorHeight); // does nothing
+	IMPORT_C virtual void SetCropInTwips(const TMargins& aMargins); // does nothing
+	IMPORT_C virtual TPictureCapability Capability() const; // no scale, no crop
+	IMPORT_C virtual void GetCropInTwips(TMargins& aMargins) const; // returns no crop
+	IMPORT_C virtual TInt ScaleFactorWidth() const; // returns no scaling
+	IMPORT_C virtual TInt ScaleFactorHeight() const; // returns no scaling
+	IMPORT_C virtual TBool LineBreakPossible(TUint aClass,TBool aBeforePicture,TBool aHaveSpaces) const;
+	IMPORT_C virtual TBool NativePixelSize(TSize& aPixelSize);
+
+	IMPORT_C void GetSizeInPixels(MGraphicsDeviceMap* aMap, TSize& aSize) const;
+	IMPORT_C void SetSizeInPixels(MGraphicsDeviceMap* aMap, const TSize& aSize);
+	IMPORT_C void AddCropInPixels(MGraphicsDeviceMap* aMap, const TMargins& aMargins);
+	IMPORT_C void GetSizeInTwips(TSize& aSize) const;
+	IMPORT_C void SetSizeInTwips(const TSize& aSize);
+	IMPORT_C void ResetToOriginal();
+protected:
+	IMPORT_C CPicture();
+	};
+
+
+/** Picture header providing an interface to a stored picture. The header holds:
+
+the picture's type, encoded as a UID, which ensures that it will be restored 
+to the correct picture type
+
+the picture's size, which facilitates deferred loading
+
+the stream ID of the picture body, which is replaced by a pointer to the picture 
+object when it has been restored. 
+@publishedAll
+@released
+*/
+class TPictureHeader
+	{
+public:
+	IMPORT_C TPictureHeader();
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C void DeletePicture();
+public:
+	/** A swizzle storing either the ID of the stream in which the picture is 
+	stored, or a pointer to the internalised picture. */
+	TSwizzle<CPicture> iPicture;
+	/** A UID specifying the type of the picture. */
+	TUid iPictureType;
+	/** The original size of the picture. */
+	TSize iSize;
+	};
+
+
+/** Abstract interface for instantiating and restoring new CPicture derived 
+objects.
+
+A concrete derived class creates pictures of one or more specific types. The 
+class has no member data and just one function, NewPictureL, that needs to 
+be provided by derived classes. 
+@publishedAll
+@released
+*/
+class MPictureFactory
+	{
+public:
+	/** Interface to the picture restoration process that ensures that a 
+	picture of the correct type is restored.
+	
+	The class of the object to be restored is determined by the UID of the 
+	stored picture, contained in the specified picture header.
+	
+	The function can allow the restoration of:
+	
+	just one CPicture-derived class, returning an error if the UID indicates 
+	that the stored picture is not of the required type
+	
+	many different CPicture-derived classes, using the UID to choose which of 
+	the possible CPicture-derived classes should be instantiated
+	
+	@param aHeader The picture header that should be restored. 
+	@param aDeferredPictureStore The store in which both the header and picture 
+	reside. */
+	virtual void NewPictureL(TPictureHeader& aHeader,const CStreamStore& aDeferredPictureStore)const=0;
+	};
+
+// printing classes
+
+/**
+The maximum length of a printer model name.
+@see TPrinterModelName 
+@publishedAll
+@released
+*/
+const TInt KMaxPrinterModelNameLength=0x20;
+
+/**
+Defines a modifiable buffer descriptor that can contain the name of a
+printer model. The maximum length of the buffer is 32.
+@since 5.0 
+@publishedAll
+@released
+*/
+typedef TBuf<KMaxPrinterModelNameLength> TPrinterModelName;
+
+/** Page specification for a print operation.
+
+  The page specification consists of the page orientation and the page
+size in twips or pixels. By default, the page orientation is portrait.
+When using landscape orientation, the left hand side of the page
+becomes the top. 
+"gdi.lib"
+@since 5.0
+@publishedAll
+@released
+*/	
+class TPageSpec
+	{
+public:
+	/**The available page orientations. */
+	enum TPageOrientation
+		{
+		/** Portrait page orientation */
+		EPortrait,
+		/** Landscape page orientation */
+		ELandscape
+		};
+public:
+	IMPORT_C TPageSpec();
+	IMPORT_C TPageSpec(TPageOrientation aOrientation,const TSize& aSize);
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C TSize OrientedPageSize() const;
+	IMPORT_C TBool operator==(const TPageSpec& aPageSpec) const;
+	IMPORT_C TBool operator!=(const TPageSpec& aPageSpec) const;
+public:
+	/** The width and height of the page in portrait orientation in twips or 
+	pixels.
+	
+	Note that OrientedPageSize() returns the width and height in reverse order 
+	for a landscape portrait. */
+	TSize iPortraitPageSize;
+	/** The page orientation. */
+	TPageOrientation iOrientation;
+	};
+
+
+/**  Controls the attributes of the band to be printed.
+
+An object of this type is passed as a parameter to functions.
+MPageRegionPrinter::PrintBandL() and CPrinterControl::QueueGetBand().
+@see MPageRegionPrinter::PrintBandL()
+@see CPrinterControl::QueueGetBand() 
+@since 5.0
+@publishedAll
+@released
+*/	
+class TBandAttributes
+    {
+public:
+	/** The width and height of the band in twips or pixels. */
+	TRect iRect;
+	/** ETrue to draw no text to the band; EFalse to draw text. */
+	TBool iTextIsIgnored; // any text drawing to this band is ignored
+	/** ETrue to draw no graphics to the band; EFalse to draw graphics. */
+	TBool iGraphicsIsIgnored; // any graphics drawing to this band is ignored
+	/** ETrue if band is the first band on the page; EFalse if not. */
+	TBool iFirstBandOnPage;
+	};
+
+/**  Printer port interface.
+
+This interface is used as the base class for the various types of
+printer port. New printer port classes should be derived from this
+class.After allocation and construction, a pointer to a concrete
+printer port should be passed to
+CPrintSetup::StartPrintL().
+@see CPrintSetup::StartPrintL() 
+@since 5.0
+@publishedAll
+@released
+*/
+class CPrinterPort : public CBase
+	{
+public:
+	/** Writes data asynchronously to the printer port.
+	
+	@param aBuf Data to be written to the port 
+	@param aRequestStatus A reference to the request status object. If the 
+	request is cancelled, this should be set to KErrCancel; if the request 
+	completes normally, this should be set to KErrNone. */
+	virtual void WriteRequest(const TDesC8& aBuf,TRequestStatus& aRequestStatus)=0;
+ 
+	/** Cancels an outstanding WriteRequest() operation. */
+	virtual void Cancel()=0;
+	};
+
+
+/** Detailed information about a printer model. 
+"gdi.lib" 
+@since 5.0
+@publishedAll
+@released
+*/
+class TPrinterModelEntry
+  	{
+public:
+	/** The name of the printer model. */
+	TPrinterModelName iModelName;
+	/** If ETrue, then a printer port is required. */
+	TBool iRequiresPrinterPort;
+	/** The UID associated with this printer model. */
+	TUid iUid;
+public:
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	};
+
+
+/** Information about a printer model.
+
+An instance of this class consists of a TPrinterModelEntry and a stream ID, 
+and is passed to CPrinterDevice::SetModel().
+
+@see CPrinterDevice 
+@publishedAll
+@released
+*/
+class TPrinterModelHeader
+    {
+public:
+	/** The printer model. */
+	TPrinterModelEntry iEntry;
+	/** The stream ID for model data. */
+	TStreamId iModelDataStreamId;
+public:
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	};
+
+
+/** Printer control interface.
+
+This abstract base class acts as the interface between a CPrinterDevice object 
+and the printer. It creates the context for, and controls the progress and 
+termination of the print job.
+
+Only those who need to add new printer drivers should write derived classes. 
+After instantiation of such a class, using CPrinterDevice::CreateControlL(), 
+the object can be accessed via the iControl member of CPrinterDevice.
+
+@see CPrinterDevice 
+@publishedAll
+@released
+*/
+class CPrinterControl : public CBase
+    {
+public:
+	/** Flags indicating whether there is more on the page to print. */
+	enum TMoreOnPage
+		{
+		/** Indicates there is more to print on the current page. */
+		EMoreOnPage,
+		/** Indicates there is no more to print on the current page. */
+		ENoMoreOnPage
+		};
+public:
+	IMPORT_C ~CPrinterControl();
+
+	/** Gets the number of bands per page.
+ 
+ 	@return The number of bands on each page. */
+	virtual TInt BandsPerPage()=0;
+
+	/**  Prints the next band on the page.
+ 
+ 	This is an asynchronous function.
+ 	@param  aStatus Request status object. On successful completion
+    contains KErrNone, otherwise another of the system-wide 
+    error codes.
+ 	@param aBand  On return, indicates the attributes of the band, including 
+ 	its height and width and whether or not the device will ignore one or 
+ 	other of graphics or text output. This information may be used by 
+ 	applications to draw more efficiently, or may be ignored
+ 	@return EMoreOnPage, if any unprinted bands remain on the 
+ 	current page. ENoMoreOnPage, if the current band is last on 
+ 	page. */
+	virtual TMoreOnPage QueueGetBand(TRequestStatus& aStatus, TBandAttributes& aBand)=0; // returns affirmative if more to print on current page
+
+	/** Terminates the print process.
+
+	This is an asynchronous function and is called when no more bands in
+	the document remain to be printed.Note that all bands have been
+	printed when no more pages or copies remain to be printed, and
+	QueueGetBand() returns ENoMoreToPrint.
+
+	@param aStatus Request status object. On successful completion contains 
+	KErrNone, otherwise another of the system-wide error codes. */
+	virtual void QueueEndPrint(TRequestStatus& aStatus)=0; 
+
+	/** Aborts the print process before it has completed.
+	
+	This function should be called if QueueGetBand() reports an error. */
+	virtual void AbortPrint()=0; // tidy up synchronously in a short time, return success code
+protected:
+	IMPORT_C CPrinterControl(CPrinterPort* aPrinterPort);
+protected:
+	/** State flags. */
+	enum TState 
+		{
+		/** Not printing. */
+		ENotPrinting, 
+		/** Printing. */
+		EPrinting
+		};
+	/** Printing state. */
+	TState iState;
+	/** Printer port. */
+	CPrinterPort* iPrinterPort;
+	};
+
+class CDictionaryStore;
+class RFs;
+
+/** Printer graphics device interface.
+
+This abstract class represents a physical graphics device that is used for 
+printing.
+
+This class is used to:
+
+set and get the page specification
+
+map between the co-ordinates of the printed page (in twips) and the co-ordinates 
+of the image device (in pixels)
+
+get and set the printer model entry
+
+create and delete a printer control.
+
+A printer driver is defined in terms of a printer device and a printer control. 
+A printer device can own either a single or no printer control. The control 
+determines the progress and termination of the print job and is responsible 
+for producing output.
+
+@see CPrinterControl 
+@publishedAll
+@released
+*/
+class CPrinterDevice : public CGraphicsDevice
+	{
+public:
+	IMPORT_C ~CPrinterDevice();
+
+	/** Gets the current page specification in twips.
+	
+	@return The current page specification, in twips. */
+	inline TPageSpec CurrentPageSpecInTwips() const {return(iCurrentPageSpecInTwips);}
+
+	/** Sets the page specification in twips.
+	
+	@param aPageSpec The page specification in twips. */
+	IMPORT_C virtual void SelectPageSpecInTwips(const TPageSpec& aPageSpec);
+	IMPORT_C virtual TRect PrintablePageInPixels() const;
+
+	/** Gets the printer model entry.
+	
+	@return The printer model entry. */
+	virtual TPrinterModelEntry Model()const =0;
+
+	/** Sets the printer model header and the store.
+	
+	@param aModel The printer model header.
+	@param aStore  The store.
+	@return KErrNone if successful; otherwise, another of the system-wide 
+	error codes.*/
+	virtual TInt SetModel(const TPrinterModelHeader& aModel,CStreamStore& aStore)=0;
+
+	/** Creates a printer control.
+	
+	The printer control is an instance of a CPrinterControl derived class; it 
+	is assigned to this printer device's iControl member.
+	
+	Note that this function is called by CPrintSetup::StartPrintL().
+	
+	@param aPrinterPort Pointer to an instance of a printer port. */
+	virtual void CreateControlL(CPrinterPort* aPrinterPort)=0;
+	IMPORT_C virtual void DeleteControl();
+
+	/**  Externalizes printer properties to the store.
+
+	The default implementation is empty.
+
+	@param  aStream  The read stream. */
+	virtual void InternalizePropertiesL(RReadStream& /*aStream*/) {}
+
+	/**  Externalizes printer properties to the store.
+	
+	The default implementation is empty.
+	
+	@param  aStream  The write stream. */
+	virtual void ExternalizePropertiesL(RWriteStream& /*aStream*/) const {}
+	IMPORT_C void RestorePropertiesL();
+	IMPORT_C void StorePropertiesL() const;
+protected:
+	IMPORT_C CPrinterDevice();
+public:
+	/** The printer control.
+	
+	This may be NULL. If implemented, it provides control over the print 
+	operation. */
+	CPrinterControl* iControl;
+protected:
+	/** Current page specification in twips. */
+	TPageSpec iCurrentPageSpecInTwips;
+	};
+
+
+/** Printer model list interface.
+
+Functions provided by this abstract base class can be used to extract printer 
+model information from the list of printer models. This class would typically 
+be used to implement printer selection in a dialog box.
+
+@see CPdrModelList 
+@publishedAll
+@released
+*/
+class CPrinterModelList : public CBase
+     {
+public:
+	/** Gets the number of printer models in the printer model list.
+ 
+ 	@return The number of printer models. */
+    virtual TInt ModelCount() const=0;
+
+	/**Gets printer model name.
+ 
+	This is the name of the printer model at the specified index within
+	the list of printer models.
+ 
+	@param  anIndex The index of the printer model within the array of
+    printer models. Note that this number must be between zero and 
+    ModelCount().
+    @return Name of printer model, up to 32 characters long */
+    virtual const TPrinterModelEntry operator[](TInt anIndex)=0;
+
+	/** Gets a printer models index within the model list from its UID.
+
+	@param aModelUid The UID of the printer model.
+	@return  The index of the printer model within the array of printer models.*/
+	virtual TInt UidToNum(TUid aModelUid) const=0;
+    };
+
+
+/** Interface for printing in bands.
+
+This class provides a single PrintBandL() function that prints 
+the body of each page band by band. Classes derived from this interface must 
+provide an implementation of the PrintBandL() function. 
+@since 5.0 
+@publishedAll
+@released
+*/
+class MPageRegionPrinter
+	{
+public:
+	/** Prints a band.
+	
+	Implementations should set up a graphics context to which all drawing should 
+	take place using CGraphicsDevice::CreateContext(). All co-ordinate 
+	calculations should be done in twips, and converted into pixels before 
+	starting the print job.
+	
+	@param aDevice Pointer to the graphics device representing the printer.
+	@param aPageNo The number of the page containing the band to be printed.
+	@param aBandInPixels Attributes of the band to be printed. */
+	virtual void PrintBandL(CGraphicsDevice* aDevice,TInt aPageNo,const TBandAttributes& aBandInPixels)=0;
+	};
+
+/**
+The UID value of a printer specification data store. 
+@publishedAll
+@released
+*/
+const TInt KPdrStoreFileUidVal=268435514;
+
+const TInt KPdlUidVal=268450588;
+const TInt KUdlUidVal=268450589;
+
+
+/** Printer specific user interface.
+
+The class is used to implement a printer specific setup dialog. A concrete 
+implementation of the class is supplied in a UDL (i.e. a UI DLL).
+
+CPrinterDriver::CreatePrinterDriverUIL() is used to construct a CPrinterDriverUI 
+object for a specific printer. (This function calls the ordinal 1 exported 
+function of the UDL that performs the construction of the CPrinterDriverUI 
+object).
+
+@see CPrinterDriver::CreatePrinterDriverUIL() 
+@publishedAll
+@released
+*/
+class CPrinterDriverUI : public CBase
+    {
+protected:
+	IMPORT_C CPrinterDriverUI();
+public:
+	IMPORT_C virtual TBool BeforePrintL();
+	IMPORT_C virtual void AfterPrintL();
+	IMPORT_C virtual void SetPropertiesL();
+	IMPORT_C virtual TBool CanSetProperties();
+
+	/** Sets the printer device.
+	
+	@param aPrinterDevice The printer device. */
+	virtual TInt SetPrinterDevice(CPrinterDevice* aPrinterDevice)=0;
+	};
+								   
+class CFileStore;
+
+
+/** Provides access to a store containing printer specification data.
+
+Printer specification data is held as a direct file store, and usually has 
+a .pdr file type.
+
+A printer driver is implemented as two files: a PDR file containing the printer 
+specification data and a PDL file containing the code to link the printer 
+with the graphics printing system.
+
+The printer specification data is generated by compiling a text file (a .pd 
+file type) using the pdrtran tool. Printer specification data defines:
+
+the name of the associated PDL
+
+a list of one or more models supported by this driver, identified by name 
+and UID
+
+device information such as the size of the device, typeface information for 
+each model, including which typefaces are supported, the heights available 
+in each typeface and the width of each character in a font.
+
+@see CPrinterDriverUI 
+@publishedAll
+@released
+*/
+class CPrinterDriver : public CBase
+     {
+public:
+	IMPORT_C static CPrinterDriver* NewL();
+	IMPORT_C ~CPrinterDriver();
+	IMPORT_C void OpenPdrL(const TDesC &aName);
+	IMPORT_C void Close();
+	IMPORT_C TInt NumModels() const;
+	IMPORT_C TPrinterModelEntry Model(TInt aNum) const;
+
+	/** Gets the associated graphics printer device.
+	
+	@return The physical graphics device used for printing. */
+	inline CPrinterDevice* PrinterDevice() {return iPrinterDevice;}
+	IMPORT_C CPrinterDevice* CreatePrinterDeviceL(TUid aModelUid);
+	IMPORT_C CPrinterDriverUI* CreatePrinterDriverUIL();
+private:
+	CPrinterDriver();
+	void DeletePrinterDevice();
+	void DoOpenPdrL(const TDesC &aName);
+	void DoCreatePrinterDeviceL(TUid aModelUid);
+	void LoadLibraryL(RLibrary& aLibrary,const TDesC& aExt,TUid aUid2);
+private:
+	RFs iFs;
+	CFileStore *iPdrStore;
+	TInt iNumModels;
+	TPrinterModelHeader* iModelList;
+	TFileName iPdlName;
+	TUid iPdlUid;
+	RLibrary iPdlLibrary;
+	CPrinterDevice* iPrinterDevice;
+	RLibrary iUdlLibrary;
+	};
+
+class RResourceFile;
+
+
+/** Implements a printer model list interface for a collection of PDR files. 
+@publishedAll
+@released
+*/
+class CPdrModelList : public CPrinterModelList
+    {
+public:
+	IMPORT_C static CPdrModelList* NewL();
+	IMPORT_C virtual ~CPdrModelList();
+    IMPORT_C TInt ModelCount() const;
+    IMPORT_C const TPrinterModelEntry operator [] (TInt anIndex);
+	IMPORT_C TInt UidToNum(TUid aModelUid) const;  // returns KErrNotFound the model uid is not matched
+	IMPORT_C void AddDirectoryL(const TDesC& aDir);
+	IMPORT_C CPrinterModelList* ScanForModelsL();
+	IMPORT_C CPrinterDriver* CreatePrinterDriverL(TInt anIndex);
+private:
+	CPdrModelList();
+	void ConstructL();
+private:
+	class TFileEntry
+		{
+	public:
+		TFileName iFileName;
+		TDesC* iDirectory;
+		};
+	class TModelEntry
+		{
+	public:
+		TPrinterModelEntry iEntry;
+		TFileEntry* iFile; 
+		};
+private:
+	void ScanDirectoryL(TInt aDirIndex);
+	void ListModelsL(TInt aFileIndex, TParse& aParser, TFileName& aNameOfLoadedResourceFile, TFileName& aTempFileName, RResourceFile& aResourceFile, HBufC8*& aResource);
+	HBufC* NewPathBufL(const TFileEntry& aFileEntry);
+private:
+	CArrayFixSeg<TModelEntry>* iModelArray;
+	CArrayFixFlat<TFileEntry>* iFileArray;
+	CArrayFixFlat<HBufC*>* iDirectoryArray;
+	RFs iFileServer;
+	};
+
+ 
+/** The interface for mapping between twips and device-specific units enriched 
+with facilities to allow zooming. 
+
+The class is recursive, because a TZoomFactor object can have a 
+MGraphicsDeviceMap (which could itself be a TZoomFactor) in its member data. 
+This allows a zoom factor object to contain another zoom factor object, and 
+is used to allow objects with different zoom factors to be embedded in each 
+other to an arbitrary depth by the application architecture. 
+@publishedAll
+@released
+*/
+class TZoomFactor : public MGraphicsDeviceMap
+	{
+public:
+	IMPORT_C TZoomFactor();
+	IMPORT_C ~TZoomFactor();
+	inline TZoomFactor(const MGraphicsDeviceMap* aDevice);
+	inline TZoomFactor(const TZoomFactor* aDevice);
+	IMPORT_C TInt ZoomFactor() const;
+	IMPORT_C void SetZoomFactor(TInt aZoomFactor);
+	inline void SetGraphicsDeviceMap(const MGraphicsDeviceMap* aDevice);
+	inline const MGraphicsDeviceMap* GraphicsDeviceMap() const;
+	IMPORT_C void SetTwipToPixelMapping(const TSize& aSizeInPixels,const TSize& aSizeInTwips);
+	IMPORT_C TInt HorizontalTwipsToPixels(TInt aTwipWidth) const;
+	IMPORT_C TInt VerticalTwipsToPixels(TInt aTwipHeight) const;
+	IMPORT_C TInt HorizontalPixelsToTwips(TInt aPixelWidth) const;
+	IMPORT_C TInt VerticalPixelsToTwips(TInt aPixelHeight) const;
+	IMPORT_C TInt GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec);
+	IMPORT_C TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec);
+	IMPORT_C TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight);
+	IMPORT_C void ReleaseFont(CFont* aFont);
+public:
+
+	/**  One to one zoom factor.  */
+	enum {EZoomOneToOne=1000};
+private:
+	TInt iZoomFactor;
+	const MGraphicsDeviceMap* iDevice;
+	};
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS	
+#include <graphics/gdi/gdistructs.h>
+#include <graphics/gdi/gdiinline.inl>
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS	
+
+#include <gdi.inl>
+
+#endif // __GDI_H__