// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __GDI_H__

#define __GDI_H__

#include <e32base.h>

#include <f32file.h>

#include <s32std.h>

class TOpenFontCharMetrics;

class RShapeInfo;

/**

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)

/** 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;

	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