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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <gdi.h>

#include <openfont.h>

#include "GlyphSel.h"

#include "FontThai.h"

#include "FontArabic.h"

#include "FontIndic.h"

#include "GDIPANIC.h"

#include "glyphsample.h"

#include "gdiinline.inl"

#include "gdistructs.h"

#include "gdiconsts.h"

#include "gdiplatapi.h"

/**

 Names holds the types & data associated with the glyph selection

 algorithm in CFont::GetCharacterPosition().

@internalComponent

*/

namespace GlyphSelection

    {

    typedef TBool (*ProcessFunc)(TGlyphSelectionState& aGss, RShapeInfo&);

    /**

     This structure defines the fields present in each row of the GlyphTable

     datat table below. 

    @internalComponent

    */

    struct TTableEntry 

    	{

    	TUint            iLow;

    	TUint            iHigh;

    	ProcessFunc	 iProcessFunc;

    	};

    /**

     This table encodes the Unicode character ranges and the glyph selector

     classes to be used for each character range when processing characters

     into glyph clusters in CFont::GetCharacterPosition().

     New glyph selection classes must make sure they are listed in this 

     table to ensure they are invoked as required.

     A '0' iProcessFunc entry tells the algorithm to skip the character.

    @internalComponent

    */

    static const TTableEntry Table[] =

    	{

    	//    iLow,     iHigh,    iProcessFunc

    		{ 0x0000,   0x00AC,   GlyphSelector_Default::Process},

    		{ 0x00AD,   0x00AD,   GlyphSelector_SoftHyphen::Process},

    		{ 0x00AE,   0x05FF,   GlyphSelector_Default::Process},

    		{ 0x0600,   0x06FF,   GlyphSelector_Arabic::Process},

    		{ 0x0700,   0x08FF,   GlyphSelector_Default::Process},

    		{ 0x0900,   0x0970,   GlyphSelector_Devanagari::Process},

    		{ 0x0980,   0x09FF,   GlyphSelector_Bengali::Process},

    		{ 0x0A00,   0x0A7F,   GlyphSelector_Gurmukhi::Process},

    		{ 0x0A80,   0x0AFF,   GlyphSelector_Gujarati::Process},

    		{ 0x0B80,   0x0BFF,   GlyphSelector_Tamil::Process},

    		{ 0x0C00,	0x0C7F,   GlyphSelector_Telugu::Process},

    		{ 0x0C80,	0x0CFF,   GlyphSelector_Kannada::Process},

    		{ 0x0D00,   0x0D7F,   GlyphSelector_Malayalam::Process},    		

    		{ 0x0D80,   0x0DFF,   GlyphSelector_Default::Process},

    		{ 0x0E00,   0x0E32,   GlyphSelector_Thai::Process},

    		{ 0x0E33,   0x0E33,   GlyphSelector_ThaiSaraAm::Process},

    		{ 0x0E34,   0x0E7F,   GlyphSelector_Thai::Process},

    		{ 0x0E80,   0x200B,   GlyphSelector_Default::Process},

    		{ 0x200C,   0x200F,   0},

    		{ 0x2010,   0x2029,   GlyphSelector_Default::Process},

    		{ 0x202A,   0x202E,   0},

    		{ 0x202F,   0xFFFD,   GlyphSelector_Default::Process},

    		{ 0xFFFE,   0xFFFF,   0},

    		{ 0x10000,	0x10FFFF, GlyphSelector_Default::Process},

    		{0xFFFFFFFF,0xFFFFFFFF, 0}

    	};

    }

/** Find appropriate processor function for the given character.

@param aChar Character for processing.

@return processor function or 0 if the character is to be skipped.

@internalComponent */

GlyphSelection::ProcessFunc CharacterToProcessFunction(TInt aChar)

	{

	for (const GlyphSelection::TTableEntry* glyphSel = GlyphSelection::Table;

		glyphSel->iLow != 0xFFFFFFFF; glyphSel++)

		{

		if ((glyphSel->iLow <= aChar) && (aChar <= glyphSel->iHigh))

			return glyphSel->iProcessFunc;

		}

	return 0;

	}

/**

@internalTechnology For use by TFontStyle/TOpenFontSpec.

*/

EXPORT_C TBool FontEffect::IsEffectOn(TEffect aEffect, TUint32 aFontEffect)

	{

	return aEffect & aFontEffect;

	}

/**

@internalTechnology For use by TFontStyle/TOpenFontSpec.

*/

EXPORT_C void FontEffect::SetEffect(TEffect aEffect, TBool aOn, TUint32& aFontEffect)

	{

	if (aOn)

		aFontEffect |= aEffect;

	else

		aFontEffect &= ~aEffect;

	}

//

// TFontStyle

//

/** Default C++ constructor. */

EXPORT_C TFontStyle::TFontStyle():

	iFlags(0), iReserved1(0), iReserved2(0)

	{}

/** Constructs a TFontStyle object with the specified attributes.

@param aPost The posture attribute. 

@param aStrWgt The stroke weight attribute. 

@param aPrintPos The print position attribute. */

EXPORT_C TFontStyle::TFontStyle(TFontPosture aPostr,TFontStrokeWeight aWgt,TFontPrintPosition aPos):

	iFlags(0), iReserved1(0), iReserved2(0)

	{

	if (aPostr == EPostureItalic)

		{

		iFlags |= EItalic;

		}

	if (aWgt == EStrokeWeightBold)

		{

		iFlags |= EBold;

		}

	if (aPos == EPrintPosSuperscript)

		{

		iFlags |= ESuper;

		}

	else if (aPos == EPrintPosSubscript)

		{

		iFlags |= ESub;

		}

	}

EXPORT_C void TFontStyle::InternalizeL(RReadStream& aStream)

/** Internalises a font style from a read stream.

The presence of this function means that the standard templated operator>>() 

(defined in s32strm.h) is available to internalise objects of this class.

@param aStream The stream from which the font style is to be internalised 

@leave KErrNoMemory If there is a problem reading from the stream.

If internalisation causes an out of memory error. */

	{

	iFlags = aStream.ReadUint32L();

	}

EXPORT_C void TFontStyle::ExternalizeL(RWriteStream& aStream) const

/** Externalises the font style to a write stream.

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class.

@param aStream The stream to which the font style is to be externalised.

@leave KErrNoMemory This function may leave, if the write action causes the 

stream's resources to be exhausted. */

	{

	aStream.WriteUint32L(iFlags);

	}

EXPORT_C TFontPosture TFontStyle::Posture() const

/** Gets the posture attribute.

@return The font style's posture. */

	{

	if(iFlags&EItalic) return(EPostureItalic);

	return(EPostureUpright);

	}

EXPORT_C TFontStrokeWeight TFontStyle::StrokeWeight() const

/** Gets the stroke weight attribute.

@return The font style's stroke weight. */

	{

	if(iFlags&EBold) return(EStrokeWeightBold);

	return(EStrokeWeightNormal);

	}

EXPORT_C TFontPrintPosition TFontStyle::PrintPosition() const

/** Gets the print position attribute.

@return The font style's print position. */

	{

	if((iFlags&ESuper) && !(iFlags&ESub)) return(EPrintPosSuperscript);

	else if((iFlags&ESub) && !(iFlags&ESuper)) return(EPrintPosSubscript);

	return(EPrintPosNormal);

	}

EXPORT_C void TFontStyle::SetPosture(TFontPosture aPosture)

/** Sets the posture attribute.

@param aPosture The posture to be set. */

	{

	if(aPosture==EPostureItalic) iFlags|=EItalic;

	else iFlags&=~EItalic;

	}

EXPORT_C void TFontStyle::SetStrokeWeight(TFontStrokeWeight aStrokeWeight)

/** Sets the stroke weight attribute.

@param aStrokeWeight The stroke weight to be set. */

	{

	if(aStrokeWeight==EStrokeWeightBold) iFlags|=EBold;

	else iFlags&=~EBold;

	}

EXPORT_C void TFontStyle::SetPrintPosition(TFontPrintPosition aPrintPosition)

/** Sets the print position attribute.

@param aPrintPosition The print position to be set. */

	{

	switch(aPrintPosition)

		{

		case EPrintPosSuperscript:

			{

			iFlags|=ESuper;

			iFlags&=~ESub;

			break;

			}

		case EPrintPosSubscript:

			{

			iFlags&=~ESuper;

			iFlags|=ESub;

			break;

			}

		default:

			{

			iFlags&=~ESuper;

			iFlags&=~ESub;

			}

	 	}

	}

/** Gets the font effects flags.

@publishedAll

@released

@return The font effects flags.

@see TFontStyle::SetEffects()

*/

EXPORT_C TUint32 TFontStyle::Effects() const

	{

	return 0xFFF0 & iFlags;

	}

/** Checks if a font effect is on.

@publishedAll

@released

@return True represents the specified font effect is on, otherwise off.

@param aEffect The font effect to be checked.

@see TFontStyle::SetEffects()

*/

EXPORT_C TBool TFontStyle::IsEffectOn(FontEffect::TEffect aEffect) const

	{

	return FontEffect::IsEffectOn(aEffect, iFlags);

	}

/** Sets the font effects flags.

@publishedAll

@released

@param aEffect The font effects flags to be set.

@see TFontStyle::Effects()

*/

EXPORT_C void TFontStyle::SetEffects(TUint32 aEffects)

	{

	iFlags &= 0xFFFF000F;

	iFlags |= 0xFFF0 & aEffects;

	}

/** Sets a font effect to the given state.

@publishedAll

@released

@param aEffect The font effect to be set.

@param aOn True represents on, otherwise off.

@see TFontStyle::IsEffectOn()

*/

EXPORT_C void TFontStyle::SetEffects(FontEffect::TEffect aEffect, TBool aOn)

	{

	FontEffect::SetEffect(aEffect, aOn, iFlags);

	}

/** Compares a font style for equality.

@publishedAll

@released

@param aFontStyle The font style to be compared with this font style.

@return ETrue, if this TFontStyle is equal to aFontStyle, EFalse, otherwise.

*/

EXPORT_C TBool TFontStyle::operator==(const TFontStyle& aFontStyle) const

	{

	return iFlags == aFontStyle.iFlags;

	}

//

// TFontSpec

//

EXPORT_C TFontSpec::TFontSpec():

	iTypeface(),

	iHeight(0),

	iFontStyle()

/** Default constructor.

The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 

and EPrintPosNormal. */

	{}

EXPORT_C TFontSpec::TFontSpec(const TDesC& aTypefaceName,TInt aHeight):

	iTypeface(),

	iHeight(aHeight),

	iFontStyle(EPostureUpright,EStrokeWeightNormal,EPrintPosNormal)

/** Constructs a TFontSpec object with the specified typeface and height. 

The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 

and EPrintPosNormal.

@param aTypefaceName The name of the typeface (e.g. "Roman"). It should be no

	longer than KMaxTypefaceNameLength characters in length.

@param aHeight The height of the typeface, in twips. 

@panic GDI 6, if aTypefaceName is more than KMaxTypefaceNameLength characters long.

*/

	{

	iTypeface.SetName(aTypefaceName);

	}

EXPORT_C TBool TFontSpec::operator==(const TFontSpec& aFontSpec) const

/** Compares this font specification with another.

@param aFontSpec The font specification to be compared with this one. 

@return ETrue, if the TFontSpecs are identical, EFalse otherwise.

*/

	{

	return

		iHeight		== aFontSpec.iHeight &&

		iFontStyle	== aFontSpec.iFontStyle &&

		iTypeface	== aFontSpec.iTypeface;

	}

EXPORT_C void TFontSpec::InternalizeL(RReadStream& aStream)

/** Internalises a font specification from a read stream.

The presence of this function means that the standard templated operator>>() 

(defined in s32strm.h) is available to internalise objects of this class.

@param aStream The stream from which the font specification is to be internalised.

@leave KErrNoMemory If internalisation causes an out of memory error. */

	{

	iTypeface.InternalizeL(aStream);

	iHeight=aStream.ReadUint16L();

	iFontStyle.InternalizeL(aStream);

	}

EXPORT_C void TFontSpec::ExternalizeL(RWriteStream& aStream) const

/** Externalises the font specification to a write stream.

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class.

@param aStream The stream to which the font specification is to be externalised 

@leave KErrNoMemory If the write action causes the stream's resources to be 

exhausted. */

	{

	iTypeface.ExternalizeL(aStream);

	aStream.WriteUint16L(iHeight);

	iFontStyle.ExternalizeL(aStream);

	}

EXPORT_C void TFontSpec::SetScriptTypeForMetrics(TLanguage aLanguage)

/** Specifies the script with which font metrics calculation will be based on.

@param aLanguage The language used to derive the required script.

@publishedAll

@released

*/

	{

	iTypeface.SetScriptTypeForMetrics(aLanguage);

	}

EXPORT_C TInt TFontSpec::ScriptTypeForMetrics() const

/** Returns the script with which font metrics calculation will be based on.

@internalTechnology

*/

	{

	return iTypeface.ScriptTypeForMetrics();

	}

//

// TTypeface

//

static const TInt KTTypefaceBitsNumAttrib = 3;

static const TInt KTTypefaceBitsNumScript = 4;

static const TInt KTTypefaceMaskAttrib = (1 << KTTypefaceBitsNumAttrib) - 1;

static const TInt KTTypefaceMaskScript = ((1 << KTTypefaceBitsNumScript) - 1) << KTTypefaceBitsNumAttrib;

EXPORT_C TTypeface::TTypeface():

	iName(),

	iFlags(0)

/** Default C++ constructor. */

	{}

/**

@internalComponent

*/

void TTypeface::ResetAttributes()

	{

	iFlags &= KTTypefaceMaskScript;

	}

/**

@internalComponent

*/

void TTypeface::ResetScriptType()

	{

	iFlags &= KTTypefaceMaskAttrib;

	}

EXPORT_C void TTypeface::InternalizeL(RReadStream& aStream)

/** Internalises a typeface from a read stream. 

The presence of this function means that the standard templated operator>>() 

(defined in s32strm.h) is available to internalise objects of this class.

@param aStream Stream from which the typeface is to be internalised. */

	{

	TBuf<KMaxTypefaceNameLength> tempname;

	aStream >> tempname;

	new(&iName) TBufC<KMaxTypefaceNameLength>(tempname);

	iFlags = aStream.ReadInt8L();

	}

EXPORT_C void TTypeface::ExternalizeL(RWriteStream& aStream) const

/** Externalises a typeface to a write stream. 

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class.

@param aStream The stream to which the typeface is to be externalised. */

	{

	aStream << iName;

	aStream.WriteInt8L(static_cast<TInt8>(iFlags));

	}

EXPORT_C TBool TTypeface::operator==(const TTypeface& aTypeface) const

/** Compares two typefaces for equality.

@param aTypeface The typeface to be compared with. 

@return ETrue, if this TTypeface is equal to aTypeface, otherwise EFalse. */

	{

	return

		iFlags == aTypeface.iFlags &&

		iName == aTypeface.iName;

	}

EXPORT_C void TTypeface::SetAttributes(TInt aAttributes)

/** Set the combination of attributes for this typeface.

@param aAttributes A bitmap defining the combination of attributes. */

	{

	ResetAttributes();

	iFlags |= KTTypefaceMaskAttrib & aAttributes & (EProportional | ESerif | ESymbol);

	}

EXPORT_C void TTypeface::SetIsProportional(TBool aIsProportional)

/** Sets the typeface's proportional attribute.

@param aIsProportional ETrue if the typeface is a proportional typeface, otherwise 

EFalse. */

	{

	if (aIsProportional)

		{

		iFlags |= EProportional;

		}

	else

		{

		iFlags &= ~EProportional;

		}

	}

EXPORT_C void TTypeface::SetIsSerif(TBool aIsSerif)

/** Sets the typeface's serif attribute.

@param aIsSerif ETrue if the typeface is a serif typeface, otherwise EFalse. */

	{

	if (aIsSerif)

		{

		iFlags |= ESerif;

		}

	else

		{

		iFlags &= ~ESerif;

		}

	}

EXPORT_C void TTypeface::SetIsSymbol(TBool aIsSymbol)

/** Sets the typeface's symbol attribute.

@param aIsSymbol ETrue if the typeface is a symbol typeface, otherwise EFalse. */

	{

	if (aIsSymbol)

		{

		iFlags |= ESymbol;

		}

	else

		{

		iFlags &= ~ESymbol;

		}

	}

EXPORT_C TInt TTypeface::Attributes() const

/** Gets the combination of attributes of the typeface.

@return The combination of attributes of the typeface. */

	{

	return KTTypefaceMaskAttrib & iFlags;

	}

EXPORT_C TBool TTypeface::IsProportional() const

/** Gets the typeface's proportional attribute.

@return ETrue if the typeface is proportional, EFalse otherwise. */

	{

	return KTTypefaceMaskAttrib & iFlags & EProportional;

	}

EXPORT_C TBool TTypeface::IsSerif() const

/** Gets the typeface's serif attribute.

@return ETrue if the typeface is a serif typeface, EFalse otherwise */

	{

	return KTTypefaceMaskAttrib & iFlags & ESerif;

	}

EXPORT_C TBool TTypeface::IsSymbol() const

/** Gets the typeface's symbol attribute.

@return ETrue if the typeface is a symbol typeface, EFalse otherwise */

	{

	return KTTypefaceMaskAttrib & iFlags & ESymbol;

	}

/** Specifies the script with which font metrics calculation will be based on.

@param aLanguage The language used to derive the required script.

@internalTechnology

*/

EXPORT_C void TTypeface::SetScriptTypeForMetrics(TLanguage aLanguage)

	{

	SetScriptTypeForMetrics(GlyphSample::TLanguage2TScript(aLanguage));

	}

/** Specifies the script with which font metrics calculation will be based on.

@param aScript The script.

@internalTechnology

*/

EXPORT_C void TTypeface::SetScriptTypeForMetrics(TInt aScript)

	{

	ResetScriptType();

	iFlags |= KTTypefaceMaskScript & (aScript << KTTypefaceBitsNumAttrib);

	}

/** Gets the script with which font metrics calculation will be based on.

@return The script.

@internalTechnology

*/

EXPORT_C TInt TTypeface::ScriptTypeForMetrics() const

	{

	return (KTTypefaceMaskScript & iFlags) >> KTTypefaceBitsNumAttrib;

	}

/**

Sets the name of the typeface. This method should be used rather than

directly accessing the iName public member.

@param aName The name of the typeface (e.g. "Roman"). It should be no 

	longer than KMaxTypefaceNameLength characters in length.

@panic GDI 6, if aName is more than KMaxTypefaceNameLength characters

	long.

*/

EXPORT_C void TTypeface::SetName(const TDesC& aName)

	{

	GDI_ASSERT_ALWAYS(aName.Length() <= KMaxTypefaceNameLength, EGdiPanic_TypefaceNameOverflow);

	iName=aName;

	}

/**

Returns the name of the typeface.

@return The name of the typeface.

*/

EXPORT_C const TDesC& TTypeface::Name() const

	{

	return iName;

	}

//

// CFont

//

/** Default destructor. */

EXPORT_C CFont::~CFont()

	{}

_LIT(KGdiZeroCharacter,"0");

/** Gets the width of the zero character of this font in pixels. 

This function is provided as the "0" character is roughly the average width 

of the characters of any font.

@return The width of the "0" character, in pixels. */

EXPORT_C TInt CFont::WidthZeroInPixels() const

	{

	return(TextWidthInPixels(KGdiZeroCharacter));

	}

/** Gets the font descent in pixels.

It is defined to be HeightInPixels() minus AscentInPixels().

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

EXPORT_C TInt CFont::DoDescentInPixels() const

	{

	return HeightInPixels() - AscentInPixels();

	}

/** Checks to see if the pen position needs to be included in the bounds

calculation for purposes of considering side-bearings in the line break point

@param aInput The input block. Contains the check flag and maxbounds.

@param aPenPos The current value of the pen position.

@param aBoundsBR Bottom-right bounds value.

@param aBoundsTL Top-left bounds value.

@return Whether or not MaxBounds has been exceeded

*/

LOCAL_C TBool BoundsExceeded(const CFont::TMeasureTextInput& aInput,

	const TInt& aPenPos, TInt& aBoundsBR, TInt& aBoundsTL)

	{

	if (aInput.iFlags & CFont::TMeasureTextInput::EFIncludePenPositionInBoundsCheck)

		{

		if (aInput.iFlags & CFont::TMeasureTextInput::EFVisualOrderRightToLeft)

			{

			aBoundsTL = Min(aBoundsTL, aPenPos);

			}

		else

			{

		 	aBoundsBR = Max(aBoundsBR, aPenPos);

			}

		}

 	return (aBoundsBR - aBoundsTL > aInput.iMaxBounds);

	}

/** Text measurement function.

This is a powerful text measurement function underlying all the

other text measurement functions. It takes optional input and output

parameter blocks, which may be null, and returns the advance 

width (change in pen position when drawn horizontally) of the text, or the advance

height, if the text is drawn vertically.

Some of the functions that can be performed using this

function are listed below. Many of them are used by the Text Views

API to do its typographic layout.

- Get the advance width or advance height (return value).

The advance width is the amount by which the pen advances when drawing

the text horizontally, while the advance height is the amount by which 

the pen advances when drawing the text vertically.

- Measure some text in context, so that shaping behaviour

(e.g. in Arabic) can be affected by what comes before and after the

text. Do this using TMeasureTextInput::iStartInputChar and 

TMeasureTextInput::iEndInputChar to tell the function where to start and end 

in the supplied descriptor.

- Determine how much text fits a given size by setting 

TMeasureTextInput::iMaxAdvance or TMeasureTextInput::iMaxBounds. 

- Specify letter spacing and word spacing using TMeasureTextInput::iCharJustNum,

TMeasureTextInput::iCharJustExcess, 

TMeasureTextInput::iWordJustNum and 

TMeasureTextInput::iWordJustExcess. 

- Get the number of characters drawn in TMeasureTextOutput::iChars 

when applying the various constraints in TMeasureTextInput. 

- Get the number of glyphs drawn in TMeasureTextOutput::iGlyphs. 

- Get the number of groups (formed by ligation or diacritic placement) in 

TMeasureTextOutput::iGroups. Groups are units of cursor

movement: the cursor hops over a character-plus-accent group or an

Arabic or other ligature in one go.

- Get the number of word spaces in TMeasureTextOutput::iSpaces. 

- Get the bounds of the inked-in pixels in TMeasureTextOutput::iBounds. 

- Get the size of the biggest glyph that would be drawn in TMeasureTextOutput::iMaxGlyphSize.

@param aText The text to be measured.

@param aInput The input block. This may be NULL.

@param aOutput The output block. This may be NULL.

@return The advance width if the text is drawn horizontally or the advance 

height if the text is drawn vertically. 

@panic GDI 1 In debug builds only, if TMeasureTextInput::iStartInputChar is negative.

*/

EXPORT_C TInt CFont::MeasureText(const TDesC& aText,const TMeasureTextInput* aInput,TMeasureTextOutput* aOutput) const

	{

	TMeasureTextInput input;

	if (aInput)

		input = *aInput;

	if (aOutput)

		{

		Mem::FillZ(aOutput,sizeof(*aOutput));

		aOutput->iChars = input.iStartInputChar;

		}

	TPositionParam param;

	param.iDirection = input.iDirection;

 	TBool vertical = param.iDirection == EVertical;

 	TBool penMovesLeft = EFalse;

 	if (input.iFlags & TMeasureTextInput::EFVisualOrderRightToLeft)

 		{

 		if (!vertical)

 			penMovesLeft = ETrue;

 		param.iFlags |= TPositionParam::EFLogicalOrder;

 		}

 	else if (!(input.iFlags & TMeasureTextInput::EFVisualOrder))

   		param.iFlags |= TPositionParam::EFLogicalOrder;

	param.iText.Set(aText);

	int advance = 0;

	int groups = 0;

	int spaces = 0;

	param.iPosInText = input.iStartInputChar;

	int end_char = Min(aText.Length(),input.iEndInputChar);

	TRect bounds;

	// Total advance if pen is moving left. Positive.

 	TInt rightToLeftAdvance = 0;

	// Shaping information of the text

	RShapeInfo shapeInfo;

	while (param.iPosInText < end_char)

		{

		if (!GetCharacterPosition2(param, shapeInfo))

			{

			if (aOutput)

				aOutput->iChars = param.iPosInText;

			continue;

			}

		int new_advance = vertical ? param.iPen.iY : param.iPen.iX;

		if (input.iCharJustExcess != 0)

			new_advance += CGraphicsContext::JustificationInPixels(input.iCharJustExcess,input.iCharJustNum,groups,1);

		groups++;

		// Allow justification to occur at spaces

		if (param.iOutput[0].iCode == 0x0020)

			{

			if (input.iWordJustExcess != 0)

				new_advance += CGraphicsContext::JustificationInPixels(input.iWordJustExcess,input.iWordJustNum,spaces,1);

			spaces++;

			}

		if (vertical)

			param.iPen.iY = new_advance;

		else

			param.iPen.iX = new_advance;

		if (penMovesLeft)

 			{

 			// If the pen is moving left, we will begin each cluster at (0,0)

 			// and shift the bounds to the right to compensate.

 			bounds.iTl.iX += param.iPen.iX;

 			bounds.iBr.iX += param.iPen.iX;

 			bounds.iTl.iY += param.iPen.iY;

 			bounds.iBr.iY += param.iPen.iY;

 			rightToLeftAdvance += param.iPen.iX;

 			new_advance = rightToLeftAdvance;

 			param.iPen.iX = 0;

 			param.iPen.iY = 0;

 			}

		if (aInput || aOutput)

			{

			const TPositionParam::TOutput* output = param.iOutput;

			for (int i = 0; i < param.iOutputGlyphs; i++, output++)

				{

				//if (!output->iBounds.IsEmpty()) -- optimized to:

				if (output->iBounds.iTl.iX != output->iBounds.iBr.iX

					|| output->iBounds.iTl.iY != output->iBounds.iBr.iY)

					{

					if (aOutput)

						{

						// increase iMaxGlyphSize if either dimension smaller than

						// current glyph

						TInt boundsDim = output->iBounds.iBr.iX - output->iBounds.iTl.iX;

						aOutput->iMaxGlyphSize.iWidth = aOutput->iMaxGlyphSize.iWidth < boundsDim?

							boundsDim : aOutput->iMaxGlyphSize.iWidth;

						boundsDim = output->iBounds.iBr.iY - output->iBounds.iTl.iY;

						aOutput->iMaxGlyphSize.iHeight = aOutput->iMaxGlyphSize.iHeight < boundsDim?

							boundsDim : aOutput->iMaxGlyphSize.iHeight;

						}

					//bounds.BoundingRect(output->iBounds); -- optimized to:

					if (output->iBounds.iTl.iX < bounds.iTl.iX)

						bounds.iTl.iX = output->iBounds.iTl.iX;

					if (bounds.iBr.iX < output->iBounds.iBr.iX)

						bounds.iBr.iX = output->iBounds.iBr.iX;

					if (output->iBounds.iTl.iY < bounds.iTl.iY)

						bounds.iTl.iY = output->iBounds.iTl.iY;

					if (bounds.iBr.iY < output->iBounds.iBr.iY)

						bounds.iBr.iY = output->iBounds.iBr.iY;

					}

				}

			// Would any limits be exceeded by adding this group?

			if (param.iPosInText > end_char)

				break;

			if (new_advance > input.iMaxAdvance)

				break;

			if (vertical)

				{

				if (BoundsExceeded(input, param.iPen.iY, bounds.iBr.iY, bounds.iTl.iY))

					break;

				}

			else

				{

				if (BoundsExceeded(input, param.iPen.iX, bounds.iBr.iX, bounds.iTl.iX))

					break;

				}

			if (aOutput)

				{

				aOutput->iChars = param.iPosInText;		// should this not be aOutput->iChars = param.iPosInText - input.iShartInputChar;?

				aOutput->iGlyphs += param.iOutputGlyphs;

				aOutput->iGroups = groups;

				aOutput->iSpaces = spaces;

				aOutput->iBounds = bounds;

				}

			}

		advance = new_advance;

		}

	if(shapeInfo.IsOpen())

		shapeInfo.Close();

	return advance;

	}

// These 3 functions should probably be moved to E32/Euser as part of TChar or

// similar as there seem to be several local copies of similar functions in

// various OS modules so we should remove duplication

TUint16 HighSurrogate(TUint aCode)

	{

	GDI_ASSERT_DEBUG(aCode  > 0xFFFF, EGdiPanic_InvalidInputParam);

	return STATIC_CAST(TUint16, 0xD7C0 + (aCode >> 10));

	}

TUint16 LowSurrogate(TUint aCode)

	{

	GDI_ASSERT_DEBUG(aCode  > 0xFFFF, EGdiPanic_InvalidInputParam);

	return STATIC_CAST(TUint16, 0xDC00 | (aCode & 0x3FF));

	}

TUint CombineSurrogates(TUint aHighSurrogate, TUint aLowSurrogate)

	{

	GDI_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xF800)), EGdiPanic_InvalidInputParam);

	GDI_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xFC00)), EGdiPanic_InvalidInputParam);

	GDI_ASSERT_DEBUG((0xDC00 == (aLowSurrogate & 0xFC00)), EGdiPanic_InvalidInputParam);

	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;

	}

/** Overridable function innards of GetCharacterPosition and

GetCharacterPosition2. It is generally not useful to override this function.

@publishedAll

@see GetCharacterPosition

@see GetCharacterPosition2

*/

EXPORT_C TBool CFont::DoGetCharacterPosition(TPositionParam& aParam) const

	{

	RShapeInfo shapeInfo;

	TBool r = GetCharacterPosition2(aParam, shapeInfo);

	if (shapeInfo.IsOpen())

		shapeInfo.Close();

	return r;

	}

// Find the script (and hence the correct process function) that any punctuation or digit may belong to

LOCAL_C GlyphSelection::ProcessFunc FindContextualProcessFunc(RShapeInfo& aShapeInfo, const TGlyphSelectionState aGss)

	{

	GlyphSelection::ProcessFunc processFunc = CharacterToProcessFunction(aGss.iCodeChar);

	GlyphSelection::ProcessFunc contextProcessFunc = (GlyphSelection::ProcessFunc)aShapeInfo.GetContext();

	// If context or prevCode is NULL, use processFunc,

	// else use function of context or prevCode

	if ((aGss.iCodeChar.IsDigit() || aGss.iCodeChar.IsPunctuation()) && !QuoteOrBracketPair(aGss.iCodeChar) && processFunc!=GlyphSelector_SoftHyphen::Process)

		{

		// If context is not set, check the previous char for context.

		if (contextProcessFunc == NULL)

			{

			if (aGss.iParam.iPosInText > 0)

				{

				TChar prevCode = aGss.iText.Get(-1);

				GlyphSelection::ProcessFunc prevProcessFunc = CharacterToProcessFunction(prevCode);

				if (prevProcessFunc != NULL && (prevCode.IsAlpha() || prevProcessFunc != GlyphSelector_Default::Process))

					{

					aShapeInfo.SetContext((TAny *)prevProcessFunc);

					return prevProcessFunc;

					}

				}

			} 

		else 

			return contextProcessFunc;

		return processFunc;

		}

	// set the context with current processFunc only if current char is not ignored for context.

 	if (processFunc != NULL && (aGss.iCodeChar.IsAlpha() || processFunc != GlyphSelector_Default::Process))

 			aShapeInfo.SetContext((TAny *)processFunc);

 	return processFunc;

	}

/** Takes Unicode text and produces the glyph cluster for the first character

in that text plus any combining mark characters, or for the first indic

syllable. It is responsible for contextual glyph selection, ligature creation

and diacritic placement.

@param aParam

	The input/output parameter of the text/glyph data for the algorithm.

@param aShapeInfo

	The function will cache "shaped" text (e.g. complex scripts such as

	Devanagari) here. aShapeInfo must be freshly-constructed or closed for each

	new piece of text in aParam.iText. If aParam.iText is unchanged between

	calls, aShapeInfo should be passed back in unchanged as well.

@return

	ETrue if glyphs for supplied text have been produced, EFalse in failure.

@see CFont::TPositionParam

@publishedAll

@released */

EXPORT_C TBool CFont::GetCharacterPosition2(TPositionParam& aParam, RShapeInfo& aShapeInfo) const

	{

	GDI_ASSERT_DEBUG(aParam.iPosInText>=0, EGdiPanic_InvalidInputParam);

	GDI_ASSERT_DEBUG(aParam.iText.Ptr(), EGdiPanic_InvalidInputParam);

	aParam.iOutputGlyphs = 0;

	TInt textLen = aParam.iText.Length();

	TBool outputOk = ETrue;

	TPoint penCopy = aParam.iPen;

	// Verify input parameters are sane

	if (aParam.iPosInText >= textLen)

		return EFalse;

	// Setup glyph selection algorithm data

	TUtf32Iterator textIter(aParam.iText.Ptr(), aParam.iText.Ptr()+textLen, aParam.iPosInText);