sl@0: // Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <gdi.h>
sl@0: #include <openfont.h>
sl@0: #include "GlyphSel.h"
sl@0: #include "FontThai.h"
sl@0: #include "FontArabic.h"
sl@0: #include "FontIndic.h"
sl@0: #include "GDIPANIC.h"
sl@0: #include "glyphsample.h"
sl@0: #include "gdiinline.inl"
sl@0: #include "gdistructs.h"
sl@0: #include "gdiconsts.h"
sl@0: #include "gdiplatapi.h"
sl@0: 
sl@0: /**
sl@0:  Names holds the types & data associated with the glyph selection
sl@0:  algorithm in CFont::GetCharacterPosition().
sl@0: @internalComponent
sl@0: */
sl@0: namespace GlyphSelection
sl@0:     {
sl@0: 
sl@0:     typedef TBool (*ProcessFunc)(TGlyphSelectionState& aGss, RShapeInfo&);
sl@0: 
sl@0:     /**
sl@0:      This structure defines the fields present in each row of the GlyphTable
sl@0:      datat table below. 
sl@0:     @internalComponent
sl@0:     */
sl@0:     struct TTableEntry 
sl@0:     	{
sl@0:     	TUint            iLow;
sl@0:     	TUint            iHigh;
sl@0:     	ProcessFunc	 iProcessFunc;
sl@0:     	};
sl@0: 
sl@0:     /**
sl@0:      This table encodes the Unicode character ranges and the glyph selector
sl@0:      classes to be used for each character range when processing characters
sl@0:      into glyph clusters in CFont::GetCharacterPosition().
sl@0:      New glyph selection classes must make sure they are listed in this 
sl@0:      table to ensure they are invoked as required.
sl@0:      A '0' iProcessFunc entry tells the algorithm to skip the character.
sl@0:     @internalComponent
sl@0:     */
sl@0:     static const TTableEntry Table[] =
sl@0:     	{
sl@0:     	//    iLow,     iHigh,    iProcessFunc
sl@0:     		{ 0x0000,   0x00AC,   GlyphSelector_Default::Process},
sl@0:     		{ 0x00AD,   0x00AD,   GlyphSelector_SoftHyphen::Process},
sl@0:     		{ 0x00AE,   0x05FF,   GlyphSelector_Default::Process},
sl@0:     		{ 0x0600,   0x06FF,   GlyphSelector_Arabic::Process},
sl@0:     		{ 0x0700,   0x08FF,   GlyphSelector_Default::Process},
sl@0:     		{ 0x0900,   0x0970,   GlyphSelector_Devanagari::Process},
sl@0:     		{ 0x0980,   0x09FF,   GlyphSelector_Bengali::Process},
sl@0:     		{ 0x0A00,   0x0A7F,   GlyphSelector_Gurmukhi::Process},
sl@0:     		{ 0x0A80,   0x0AFF,   GlyphSelector_Gujarati::Process},
sl@0:     		{ 0x0B80,   0x0BFF,   GlyphSelector_Tamil::Process},
sl@0:     		{ 0x0C00,	0x0C7F,   GlyphSelector_Telugu::Process},
sl@0:     		{ 0x0C80,	0x0CFF,   GlyphSelector_Kannada::Process},
sl@0:     		{ 0x0D00,   0x0D7F,   GlyphSelector_Malayalam::Process},    		
sl@0:     		{ 0x0D80,   0x0DFF,   GlyphSelector_Default::Process},
sl@0:     		{ 0x0E00,   0x0E32,   GlyphSelector_Thai::Process},
sl@0:     		{ 0x0E33,   0x0E33,   GlyphSelector_ThaiSaraAm::Process},
sl@0:     		{ 0x0E34,   0x0E7F,   GlyphSelector_Thai::Process},
sl@0:     		{ 0x0E80,   0x200B,   GlyphSelector_Default::Process},
sl@0:     		{ 0x200C,   0x200F,   0},
sl@0:     		{ 0x2010,   0x2029,   GlyphSelector_Default::Process},
sl@0:     		{ 0x202A,   0x202E,   0},
sl@0:     		{ 0x202F,   0xFFFD,   GlyphSelector_Default::Process},
sl@0:     		{ 0xFFFE,   0xFFFF,   0},
sl@0:     		{ 0x10000,	0x10FFFF, GlyphSelector_Default::Process},
sl@0:     		{0xFFFFFFFF,0xFFFFFFFF, 0}
sl@0:     	};
sl@0:     }
sl@0: 
sl@0: /** Find appropriate processor function for the given character.
sl@0: @param aChar Character for processing.
sl@0: @return processor function or 0 if the character is to be skipped.
sl@0: @internalComponent */
sl@0: GlyphSelection::ProcessFunc CharacterToProcessFunction(TInt aChar)
sl@0: 	{
sl@0: 	for (const GlyphSelection::TTableEntry* glyphSel = GlyphSelection::Table;
sl@0: 		glyphSel->iLow != 0xFFFFFFFF; glyphSel++)
sl@0: 		{
sl@0: 		if ((glyphSel->iLow <= aChar) && (aChar <= glyphSel->iHigh))
sl@0: 			return glyphSel->iProcessFunc;
sl@0: 		}
sl@0: 	return 0;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @internalTechnology For use by TFontStyle/TOpenFontSpec.
sl@0: */
sl@0: EXPORT_C TBool FontEffect::IsEffectOn(TEffect aEffect, TUint32 aFontEffect)
sl@0: 	{
sl@0: 	return aEffect & aFontEffect;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @internalTechnology For use by TFontStyle/TOpenFontSpec.
sl@0: */
sl@0: EXPORT_C void FontEffect::SetEffect(TEffect aEffect, TBool aOn, TUint32& aFontEffect)
sl@0: 	{
sl@0: 	if (aOn)
sl@0: 		aFontEffect |= aEffect;
sl@0: 	else
sl@0: 		aFontEffect &= ~aEffect;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //
sl@0: // TFontStyle
sl@0: //
sl@0: 
sl@0: /** Default C++ constructor. */
sl@0: EXPORT_C TFontStyle::TFontStyle():
sl@0: 	iFlags(0), iReserved1(0), iReserved2(0)
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: /** Constructs a TFontStyle object with the specified attributes.
sl@0: @param aPost The posture attribute. 
sl@0: @param aStrWgt The stroke weight attribute. 
sl@0: @param aPrintPos The print position attribute. */
sl@0: EXPORT_C TFontStyle::TFontStyle(TFontPosture aPostr,TFontStrokeWeight aWgt,TFontPrintPosition aPos):
sl@0: 	iFlags(0), iReserved1(0), iReserved2(0)
sl@0: 	{
sl@0: 	if (aPostr == EPostureItalic)
sl@0: 		{
sl@0: 		iFlags |= EItalic;
sl@0: 		}
sl@0: 	if (aWgt == EStrokeWeightBold)
sl@0: 		{
sl@0: 		iFlags |= EBold;
sl@0: 		}
sl@0: 	if (aPos == EPrintPosSuperscript)
sl@0: 		{
sl@0: 		iFlags |= ESuper;
sl@0: 		}
sl@0: 	else if (aPos == EPrintPosSubscript)
sl@0: 		{
sl@0: 		iFlags |= ESub;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontStyle::InternalizeL(RReadStream& aStream)
sl@0: /** Internalises a font style from a read stream.
sl@0: 
sl@0: The presence of this function means that the standard templated operator>>() 
sl@0: (defined in s32strm.h) is available to internalise objects of this class.
sl@0: 
sl@0: @param aStream The stream from which the font style is to be internalised 
sl@0: @leave KErrNoMemory If there is a problem reading from the stream.
sl@0: If internalisation causes an out of memory error. */
sl@0: 	{
sl@0: 	iFlags = aStream.ReadUint32L();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontStyle::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises the font style to a write stream.
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: (defined in s32strm.h) is available to externalise objects of this class.
sl@0: 
sl@0: @param aStream The stream to which the font style is to be externalised.
sl@0: @leave KErrNoMemory This function may leave, if the write action causes the 
sl@0: stream's resources to be exhausted. */
sl@0: 	{
sl@0: 	aStream.WriteUint32L(iFlags);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TFontPosture TFontStyle::Posture() const
sl@0: /** Gets the posture attribute.
sl@0: 
sl@0: @return The font style's posture. */
sl@0: 	{
sl@0: 	if(iFlags&EItalic) return(EPostureItalic);
sl@0: 	return(EPostureUpright);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TFontStrokeWeight TFontStyle::StrokeWeight() const
sl@0: /** Gets the stroke weight attribute.
sl@0: 
sl@0: @return The font style's stroke weight. */
sl@0: 	{
sl@0: 	if(iFlags&EBold) return(EStrokeWeightBold);
sl@0: 	return(EStrokeWeightNormal);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TFontPrintPosition TFontStyle::PrintPosition() const
sl@0: /** Gets the print position attribute.
sl@0: 
sl@0: @return The font style's print position. */
sl@0: 	{
sl@0: 	if((iFlags&ESuper) && !(iFlags&ESub)) return(EPrintPosSuperscript);
sl@0: 	else if((iFlags&ESub) && !(iFlags&ESuper)) return(EPrintPosSubscript);
sl@0: 	return(EPrintPosNormal);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontStyle::SetPosture(TFontPosture aPosture)
sl@0: /** Sets the posture attribute.
sl@0: 
sl@0: @param aPosture The posture to be set. */
sl@0: 	{
sl@0: 	if(aPosture==EPostureItalic) iFlags|=EItalic;
sl@0: 	else iFlags&=~EItalic;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontStyle::SetStrokeWeight(TFontStrokeWeight aStrokeWeight)
sl@0: /** Sets the stroke weight attribute.
sl@0: 
sl@0: @param aStrokeWeight The stroke weight to be set. */
sl@0: 	{
sl@0: 	if(aStrokeWeight==EStrokeWeightBold) iFlags|=EBold;
sl@0: 	else iFlags&=~EBold;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontStyle::SetPrintPosition(TFontPrintPosition aPrintPosition)
sl@0: /** Sets the print position attribute.
sl@0: 
sl@0: @param aPrintPosition The print position to be set. */
sl@0: 	{
sl@0: 	switch(aPrintPosition)
sl@0: 		{
sl@0: 		case EPrintPosSuperscript:
sl@0: 			{
sl@0: 			iFlags|=ESuper;
sl@0: 			iFlags&=~ESub;
sl@0: 			break;
sl@0: 			}
sl@0: 		case EPrintPosSubscript:
sl@0: 			{
sl@0: 			iFlags&=~ESuper;
sl@0: 			iFlags|=ESub;
sl@0: 			break;
sl@0: 			}
sl@0: 		default:
sl@0: 			{
sl@0: 			iFlags&=~ESuper;
sl@0: 			iFlags&=~ESub;
sl@0: 			}
sl@0: 	 	}
sl@0: 	}
sl@0: 
sl@0: /** Gets the font effects flags.
sl@0: @publishedAll
sl@0: @released
sl@0: @return The font effects flags.
sl@0: @see TFontStyle::SetEffects()
sl@0: */
sl@0: EXPORT_C TUint32 TFontStyle::Effects() const
sl@0: 	{
sl@0: 	return 0xFFF0 & iFlags;
sl@0: 	}
sl@0: 
sl@0: /** Checks if a font effect is on.
sl@0: @publishedAll
sl@0: @released
sl@0: @return True represents the specified font effect is on, otherwise off.
sl@0: @param aEffect The font effect to be checked.
sl@0: @see TFontStyle::SetEffects()
sl@0: */
sl@0: EXPORT_C TBool TFontStyle::IsEffectOn(FontEffect::TEffect aEffect) const
sl@0: 	{
sl@0: 	return FontEffect::IsEffectOn(aEffect, iFlags);
sl@0: 	}
sl@0: 
sl@0: /** Sets the font effects flags.
sl@0: @publishedAll
sl@0: @released
sl@0: @param aEffect The font effects flags to be set.
sl@0: @see TFontStyle::Effects()
sl@0: */
sl@0: EXPORT_C void TFontStyle::SetEffects(TUint32 aEffects)
sl@0: 	{
sl@0: 	iFlags &= 0xFFFF000F;
sl@0: 	iFlags |= 0xFFF0 & aEffects;
sl@0: 	}
sl@0: 
sl@0: /** Sets a font effect to the given state.
sl@0: @publishedAll
sl@0: @released
sl@0: @param aEffect The font effect to be set.
sl@0: @param aOn True represents on, otherwise off.
sl@0: @see TFontStyle::IsEffectOn()
sl@0: */
sl@0: EXPORT_C void TFontStyle::SetEffects(FontEffect::TEffect aEffect, TBool aOn)
sl@0: 	{
sl@0: 	FontEffect::SetEffect(aEffect, aOn, iFlags);
sl@0: 	}
sl@0: 
sl@0: /** Compares a font style for equality.
sl@0: @publishedAll
sl@0: @released
sl@0: @param aFontStyle The font style to be compared with this font style.
sl@0: @return ETrue, if this TFontStyle is equal to aFontStyle, EFalse, otherwise.
sl@0: */
sl@0: EXPORT_C TBool TFontStyle::operator==(const TFontStyle& aFontStyle) const
sl@0: 	{
sl@0: 	return iFlags == aFontStyle.iFlags;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // TFontSpec
sl@0: //
sl@0: EXPORT_C TFontSpec::TFontSpec():
sl@0: 	iTypeface(),
sl@0: 	iHeight(0),
sl@0: 	iFontStyle()
sl@0: /** Default constructor.
sl@0: 
sl@0: The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 
sl@0: and EPrintPosNormal. */
sl@0: 	{}
sl@0: 
sl@0: 
sl@0: EXPORT_C TFontSpec::TFontSpec(const TDesC& aTypefaceName,TInt aHeight):
sl@0: 	iTypeface(),
sl@0: 	iHeight(aHeight),
sl@0: 	iFontStyle(EPostureUpright,EStrokeWeightNormal,EPrintPosNormal)
sl@0: /** Constructs a TFontSpec object with the specified typeface and height. 
sl@0: 
sl@0: The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 
sl@0: and EPrintPosNormal.
sl@0: 
sl@0: @param aTypefaceName The name of the typeface (e.g. "Roman"). It should be no
sl@0: 	longer than KMaxTypefaceNameLength characters in length.
sl@0: @param aHeight The height of the typeface, in twips. 
sl@0: @panic GDI 6, if aTypefaceName is more than KMaxTypefaceNameLength characters long.
sl@0: */
sl@0: 	{
sl@0: 	iTypeface.SetName(aTypefaceName);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TBool TFontSpec::operator==(const TFontSpec& aFontSpec) const
sl@0: /** Compares this font specification with another.
sl@0: @param aFontSpec The font specification to be compared with this one. 
sl@0: @return ETrue, if the TFontSpecs are identical, EFalse otherwise.
sl@0: */
sl@0: 	{
sl@0: 	return
sl@0: 		iHeight		== aFontSpec.iHeight &&
sl@0: 		iFontStyle	== aFontSpec.iFontStyle &&
sl@0: 		iTypeface	== aFontSpec.iTypeface;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontSpec::InternalizeL(RReadStream& aStream)
sl@0: /** Internalises a font specification from a read stream.
sl@0: 
sl@0: The presence of this function means that the standard templated operator>>() 
sl@0: (defined in s32strm.h) is available to internalise objects of this class.
sl@0: 
sl@0: @param aStream The stream from which the font specification is to be internalised.
sl@0: @leave KErrNoMemory If internalisation causes an out of memory error. */
sl@0: 	{
sl@0: 	iTypeface.InternalizeL(aStream);
sl@0: 	iHeight=aStream.ReadUint16L();
sl@0: 	iFontStyle.InternalizeL(aStream);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TFontSpec::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises the font specification to a write stream.
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: (defined in s32strm.h) is available to externalise objects of this class.
sl@0: 
sl@0: @param aStream The stream to which the font specification is to be externalised 
sl@0: 
sl@0: @leave KErrNoMemory If the write action causes the stream's resources to be 
sl@0: exhausted. */
sl@0: 	{
sl@0: 	iTypeface.ExternalizeL(aStream);
sl@0: 	aStream.WriteUint16L(iHeight);
sl@0: 	iFontStyle.ExternalizeL(aStream);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void TFontSpec::SetScriptTypeForMetrics(TLanguage aLanguage)
sl@0: /** Specifies the script with which font metrics calculation will be based on.
sl@0: @param aLanguage The language used to derive the required script.
sl@0: @publishedAll
sl@0: @released
sl@0: */
sl@0: 	{
sl@0: 	iTypeface.SetScriptTypeForMetrics(aLanguage);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt TFontSpec::ScriptTypeForMetrics() const
sl@0: /** Returns the script with which font metrics calculation will be based on.
sl@0: @internalTechnology
sl@0: */
sl@0: 	{
sl@0: 	return iTypeface.ScriptTypeForMetrics();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // TTypeface
sl@0: //
sl@0: static const TInt KTTypefaceBitsNumAttrib = 3;
sl@0: static const TInt KTTypefaceBitsNumScript = 4;
sl@0: static const TInt KTTypefaceMaskAttrib = (1 << KTTypefaceBitsNumAttrib) - 1;
sl@0: static const TInt KTTypefaceMaskScript = ((1 << KTTypefaceBitsNumScript) - 1) << KTTypefaceBitsNumAttrib;
sl@0: EXPORT_C TTypeface::TTypeface():
sl@0: 	iName(),
sl@0: 	iFlags(0)
sl@0: /** Default C++ constructor. */
sl@0: 	{}
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: void TTypeface::ResetAttributes()
sl@0: 	{
sl@0: 	iFlags &= KTTypefaceMaskScript;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: void TTypeface::ResetScriptType()
sl@0: 	{
sl@0: 	iFlags &= KTTypefaceMaskAttrib;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void TTypeface::InternalizeL(RReadStream& aStream)
sl@0: /** Internalises a typeface from a read stream. 
sl@0: 
sl@0: The presence of this function means that the standard templated operator>>() 
sl@0: (defined in s32strm.h) is available to internalise objects of this class.
sl@0: 
sl@0: @param aStream Stream from which the typeface is to be internalised. */
sl@0: 	{
sl@0: 	TBuf<KMaxTypefaceNameLength> tempname;
sl@0: 	aStream >> tempname;
sl@0: 	new(&iName) TBufC<KMaxTypefaceNameLength>(tempname);
sl@0: 	iFlags = aStream.ReadInt8L();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TTypeface::ExternalizeL(RWriteStream& aStream) const
sl@0: /** Externalises a typeface to a write stream. 
sl@0: 
sl@0: The presence of this function means that the standard templated operator<<() 
sl@0: (defined in s32strm.h) is available to externalise objects of this class.
sl@0: 
sl@0: @param aStream The stream to which the typeface is to be externalised. */
sl@0: 	{
sl@0: 	aStream << iName;
sl@0: 	aStream.WriteInt8L(static_cast<TInt8>(iFlags));
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TBool TTypeface::operator==(const TTypeface& aTypeface) const
sl@0: /** Compares two typefaces for equality.
sl@0: 
sl@0: @param aTypeface The typeface to be compared with. 
sl@0: @return ETrue, if this TTypeface is equal to aTypeface, otherwise EFalse. */
sl@0: 	{
sl@0: 	return
sl@0: 		iFlags == aTypeface.iFlags &&
sl@0: 		iName == aTypeface.iName;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void TTypeface::SetAttributes(TInt aAttributes)
sl@0: /** Set the combination of attributes for this typeface.
sl@0: 
sl@0: @param aAttributes A bitmap defining the combination of attributes. */
sl@0: 	{
sl@0: 	ResetAttributes();
sl@0: 	iFlags |= KTTypefaceMaskAttrib & aAttributes & (EProportional | ESerif | ESymbol);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TTypeface::SetIsProportional(TBool aIsProportional)
sl@0: /** Sets the typeface's proportional attribute.
sl@0: 
sl@0: @param aIsProportional ETrue if the typeface is a proportional typeface, otherwise 
sl@0: EFalse. */
sl@0: 	{
sl@0: 	if (aIsProportional)
sl@0: 		{
sl@0: 		iFlags |= EProportional;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iFlags &= ~EProportional;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TTypeface::SetIsSerif(TBool aIsSerif)
sl@0: /** Sets the typeface's serif attribute.
sl@0: 
sl@0: @param aIsSerif ETrue if the typeface is a serif typeface, otherwise EFalse. */
sl@0: 	{
sl@0: 	if (aIsSerif)
sl@0: 		{
sl@0: 		iFlags |= ESerif;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iFlags &= ~ESerif;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C void TTypeface::SetIsSymbol(TBool aIsSymbol)
sl@0: /** Sets the typeface's symbol attribute.
sl@0: 
sl@0: @param aIsSymbol ETrue if the typeface is a symbol typeface, otherwise EFalse. */
sl@0: 	{
sl@0: 	if (aIsSymbol)
sl@0: 		{
sl@0: 		iFlags |= ESymbol;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iFlags &= ~ESymbol;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TInt TTypeface::Attributes() const
sl@0: /** Gets the combination of attributes of the typeface.
sl@0: 
sl@0: @return The combination of attributes of the typeface. */
sl@0: 	{
sl@0: 	return KTTypefaceMaskAttrib & iFlags;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TBool TTypeface::IsProportional() const
sl@0: /** Gets the typeface's proportional attribute.
sl@0: 
sl@0: @return ETrue if the typeface is proportional, EFalse otherwise. */
sl@0: 	{
sl@0: 	return KTTypefaceMaskAttrib & iFlags & EProportional;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TBool TTypeface::IsSerif() const
sl@0: /** Gets the typeface's serif attribute.
sl@0: 
sl@0: @return ETrue if the typeface is a serif typeface, EFalse otherwise */
sl@0: 	{
sl@0: 	return KTTypefaceMaskAttrib & iFlags & ESerif;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C TBool TTypeface::IsSymbol() const
sl@0: /** Gets the typeface's symbol attribute.
sl@0: 
sl@0: @return ETrue if the typeface is a symbol typeface, EFalse otherwise */
sl@0: 	{
sl@0: 	return KTTypefaceMaskAttrib & iFlags & ESymbol;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Specifies the script with which font metrics calculation will be based on.
sl@0: @param aLanguage The language used to derive the required script.
sl@0: @internalTechnology
sl@0: */
sl@0: EXPORT_C void TTypeface::SetScriptTypeForMetrics(TLanguage aLanguage)
sl@0: 	{
sl@0: 	SetScriptTypeForMetrics(GlyphSample::TLanguage2TScript(aLanguage));
sl@0: 	}
sl@0: 
sl@0: /** Specifies the script with which font metrics calculation will be based on.
sl@0: @param aScript The script.
sl@0: @internalTechnology
sl@0: */
sl@0: EXPORT_C void TTypeface::SetScriptTypeForMetrics(TInt aScript)
sl@0: 	{
sl@0: 	ResetScriptType();
sl@0: 	iFlags |= KTTypefaceMaskScript & (aScript << KTTypefaceBitsNumAttrib);
sl@0: 	}
sl@0: 
sl@0: /** Gets the script with which font metrics calculation will be based on.
sl@0: @return The script.
sl@0: @internalTechnology
sl@0: */
sl@0: EXPORT_C TInt TTypeface::ScriptTypeForMetrics() const
sl@0: 	{
sl@0: 	return (KTTypefaceMaskScript & iFlags) >> KTTypefaceBitsNumAttrib;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Sets the name of the typeface. This method should be used rather than
sl@0: directly accessing the iName public member.
sl@0: @param aName The name of the typeface (e.g. "Roman"). It should be no 
sl@0: 	longer than KMaxTypefaceNameLength characters in length.
sl@0: @panic GDI 6, if aName is more than KMaxTypefaceNameLength characters
sl@0: 	long.
sl@0: */
sl@0: EXPORT_C void TTypeface::SetName(const TDesC& aName)
sl@0: 	{
sl@0: 	GDI_ASSERT_ALWAYS(aName.Length() <= KMaxTypefaceNameLength, EGdiPanic_TypefaceNameOverflow);
sl@0: 	iName=aName;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Returns the name of the typeface.
sl@0: @return The name of the typeface.
sl@0: */
sl@0: EXPORT_C const TDesC& TTypeface::Name() const
sl@0: 	{
sl@0: 	return iName;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //
sl@0: // CFont
sl@0: //
sl@0: 
sl@0: /** Default destructor. */
sl@0: EXPORT_C CFont::~CFont()
sl@0: 	{}
sl@0: 
sl@0: _LIT(KGdiZeroCharacter,"0");
sl@0: 
sl@0: /** Gets the width of the zero character of this font in pixels. 
sl@0: 
sl@0: This function is provided as the "0" character is roughly the average width 
sl@0: of the characters of any font.
sl@0: 
sl@0: @return The width of the "0" character, in pixels. */
sl@0: EXPORT_C TInt CFont::WidthZeroInPixels() const
sl@0: 	{
sl@0: 	return(TextWidthInPixels(KGdiZeroCharacter));
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Gets the font descent in pixels.
sl@0: It is defined to be HeightInPixels() minus AscentInPixels().
sl@0: Note that this deprecated function is replaced by the new @c FontMaxDescent()
sl@0: or in some cases @c FontStandardDescent().
sl@0: 
sl@0: @return The font descent in pixels.
sl@0: @see FontStandardDescent() 
sl@0: @see FontMaxDescent()
sl@0: @deprecated */
sl@0: EXPORT_C TInt CFont::DoDescentInPixels() const
sl@0: 	{
sl@0: 	return HeightInPixels() - AscentInPixels();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Checks to see if the pen position needs to be included in the bounds
sl@0: calculation for purposes of considering side-bearings in the line break point
sl@0: 
sl@0: @param aInput The input block. Contains the check flag and maxbounds.
sl@0: @param aPenPos The current value of the pen position.
sl@0: @param aBoundsBR Bottom-right bounds value.
sl@0: @param aBoundsTL Top-left bounds value.
sl@0: @return Whether or not MaxBounds has been exceeded
sl@0: */
sl@0: LOCAL_C TBool BoundsExceeded(const CFont::TMeasureTextInput& aInput,
sl@0: 	const TInt& aPenPos, TInt& aBoundsBR, TInt& aBoundsTL)
sl@0: 	{
sl@0: 	if (aInput.iFlags & CFont::TMeasureTextInput::EFIncludePenPositionInBoundsCheck)
sl@0: 		{
sl@0: 		if (aInput.iFlags & CFont::TMeasureTextInput::EFVisualOrderRightToLeft)
sl@0: 			{
sl@0: 			aBoundsTL = Min(aBoundsTL, aPenPos);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 		 	aBoundsBR = Max(aBoundsBR, aPenPos);
sl@0: 			}
sl@0: 		}
sl@0:  	return (aBoundsBR - aBoundsTL > aInput.iMaxBounds);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Text measurement function.
sl@0: 
sl@0: This is a powerful text measurement function underlying all the
sl@0: other text measurement functions. It takes optional input and output
sl@0: parameter blocks, which may be null, and returns the advance 
sl@0: width (change in pen position when drawn horizontally) of the text, or the advance
sl@0: height, if the text is drawn vertically.
sl@0: 
sl@0: Some of the functions that can be performed using this
sl@0: function are listed below. Many of them are used by the Text Views
sl@0: API to do its typographic layout.
sl@0: - Get the advance width or advance height (return value).
sl@0: The advance width is the amount by which the pen advances when drawing
sl@0: the text horizontally, while the advance height is the amount by which 
sl@0: the pen advances when drawing the text vertically.
sl@0: - Measure some text in context, so that shaping behaviour
sl@0: (e.g. in Arabic) can be affected by what comes before and after the
sl@0: text. Do this using TMeasureTextInput::iStartInputChar and 
sl@0: TMeasureTextInput::iEndInputChar to tell the function where to start and end 
sl@0: in the supplied descriptor.
sl@0: - Determine how much text fits a given size by setting 
sl@0: TMeasureTextInput::iMaxAdvance or TMeasureTextInput::iMaxBounds. 
sl@0: - Specify letter spacing and word spacing using TMeasureTextInput::iCharJustNum,
sl@0: TMeasureTextInput::iCharJustExcess, 
sl@0: TMeasureTextInput::iWordJustNum and 
sl@0: TMeasureTextInput::iWordJustExcess. 
sl@0: - Get the number of characters drawn in TMeasureTextOutput::iChars 
sl@0: when applying the various constraints in TMeasureTextInput. 
sl@0: - Get the number of glyphs drawn in TMeasureTextOutput::iGlyphs. 
sl@0: - Get the number of groups (formed by ligation or diacritic placement) in 
sl@0: TMeasureTextOutput::iGroups. Groups are units of cursor
sl@0: movement: the cursor hops over a character-plus-accent group or an
sl@0: Arabic or other ligature in one go.
sl@0: - Get the number of word spaces in TMeasureTextOutput::iSpaces. 
sl@0: - Get the bounds of the inked-in pixels in TMeasureTextOutput::iBounds. 
sl@0: - Get the size of the biggest glyph that would be drawn in TMeasureTextOutput::iMaxGlyphSize.
sl@0: 
sl@0: @param aText The text to be measured.
sl@0: @param aInput The input block. This may be NULL.
sl@0: @param aOutput The output block. This may be NULL.
sl@0: @return The advance width if the text is drawn horizontally or the advance 
sl@0: height if the text is drawn vertically. 
sl@0: 
sl@0: @panic GDI 1 In debug builds only, if TMeasureTextInput::iStartInputChar is negative.
sl@0: */
sl@0: EXPORT_C TInt CFont::MeasureText(const TDesC& aText,const TMeasureTextInput* aInput,TMeasureTextOutput* aOutput) const
sl@0: 	{
sl@0: 	TMeasureTextInput input;
sl@0: 	if (aInput)
sl@0: 		input = *aInput;
sl@0: 	if (aOutput)
sl@0: 		{
sl@0: 		Mem::FillZ(aOutput,sizeof(*aOutput));
sl@0: 		aOutput->iChars = input.iStartInputChar;
sl@0: 		}
sl@0: 	TPositionParam param;
sl@0: 	param.iDirection = input.iDirection;
sl@0:  
sl@0:  	TBool vertical = param.iDirection == EVertical;
sl@0:  	TBool penMovesLeft = EFalse;
sl@0:  	if (input.iFlags & TMeasureTextInput::EFVisualOrderRightToLeft)
sl@0:  		{
sl@0:  		if (!vertical)
sl@0:  			penMovesLeft = ETrue;
sl@0:  		param.iFlags |= TPositionParam::EFLogicalOrder;
sl@0:  		}
sl@0:  	else if (!(input.iFlags & TMeasureTextInput::EFVisualOrder))
sl@0:    		param.iFlags |= TPositionParam::EFLogicalOrder;
sl@0: 
sl@0: 
sl@0: 	param.iText.Set(aText);
sl@0: 
sl@0: 	int advance = 0;
sl@0: 	int groups = 0;
sl@0: 	int spaces = 0;
sl@0: 	param.iPosInText = input.iStartInputChar;
sl@0: 	int end_char = Min(aText.Length(),input.iEndInputChar);
sl@0: 	TRect bounds;
sl@0: 	// Total advance if pen is moving left. Positive.
sl@0:  	TInt rightToLeftAdvance = 0;
sl@0: 	// Shaping information of the text
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	while (param.iPosInText < end_char)
sl@0: 		{
sl@0: 		if (!GetCharacterPosition2(param, shapeInfo))
sl@0: 			{
sl@0: 			if (aOutput)
sl@0: 				aOutput->iChars = param.iPosInText;
sl@0: 			continue;
sl@0: 			}
sl@0: 
sl@0: 		int new_advance = vertical ? param.iPen.iY : param.iPen.iX;
sl@0: 		if (input.iCharJustExcess != 0)
sl@0: 			new_advance += CGraphicsContext::JustificationInPixels(input.iCharJustExcess,input.iCharJustNum,groups,1);
sl@0: 		groups++;
sl@0: 		// Allow justification to occur at spaces
sl@0: 		if (param.iOutput[0].iCode == 0x0020)
sl@0: 			{
sl@0: 			if (input.iWordJustExcess != 0)
sl@0: 				new_advance += CGraphicsContext::JustificationInPixels(input.iWordJustExcess,input.iWordJustNum,spaces,1);
sl@0: 			spaces++;
sl@0: 			}
sl@0: 		if (vertical)
sl@0: 			param.iPen.iY = new_advance;
sl@0: 		else
sl@0: 			param.iPen.iX = new_advance;
sl@0: 		
sl@0: 		if (penMovesLeft)
sl@0:  			{
sl@0:  			// If the pen is moving left, we will begin each cluster at (0,0)
sl@0:  			// and shift the bounds to the right to compensate.
sl@0:  			bounds.iTl.iX += param.iPen.iX;
sl@0:  			bounds.iBr.iX += param.iPen.iX;
sl@0:  			bounds.iTl.iY += param.iPen.iY;
sl@0:  			bounds.iBr.iY += param.iPen.iY;
sl@0:  			rightToLeftAdvance += param.iPen.iX;
sl@0:  			new_advance = rightToLeftAdvance;
sl@0:  			param.iPen.iX = 0;
sl@0:  			param.iPen.iY = 0;
sl@0:  			}
sl@0: 
sl@0: 		if (aInput || aOutput)
sl@0: 			{
sl@0: 			const TPositionParam::TOutput* output = param.iOutput;
sl@0: 			for (int i = 0; i < param.iOutputGlyphs; i++, output++)
sl@0: 				{
sl@0: 				//if (!output->iBounds.IsEmpty()) -- optimized to:
sl@0: 				if (output->iBounds.iTl.iX != output->iBounds.iBr.iX
sl@0: 					|| output->iBounds.iTl.iY != output->iBounds.iBr.iY)
sl@0: 					{
sl@0: 					if (aOutput)
sl@0: 						{
sl@0: 						// increase iMaxGlyphSize if either dimension smaller than
sl@0: 						// current glyph
sl@0: 						TInt boundsDim = output->iBounds.iBr.iX - output->iBounds.iTl.iX;
sl@0: 						aOutput->iMaxGlyphSize.iWidth = aOutput->iMaxGlyphSize.iWidth < boundsDim?
sl@0: 							boundsDim : aOutput->iMaxGlyphSize.iWidth;
sl@0: 						boundsDim = output->iBounds.iBr.iY - output->iBounds.iTl.iY;
sl@0: 						aOutput->iMaxGlyphSize.iHeight = aOutput->iMaxGlyphSize.iHeight < boundsDim?
sl@0: 							boundsDim : aOutput->iMaxGlyphSize.iHeight;
sl@0: 						}
sl@0: 					//bounds.BoundingRect(output->iBounds); -- optimized to:
sl@0: 					if (output->iBounds.iTl.iX < bounds.iTl.iX)
sl@0: 						bounds.iTl.iX = output->iBounds.iTl.iX;
sl@0: 					if (bounds.iBr.iX < output->iBounds.iBr.iX)
sl@0: 						bounds.iBr.iX = output->iBounds.iBr.iX;
sl@0: 					if (output->iBounds.iTl.iY < bounds.iTl.iY)
sl@0: 						bounds.iTl.iY = output->iBounds.iTl.iY;
sl@0: 					if (bounds.iBr.iY < output->iBounds.iBr.iY)
sl@0: 						bounds.iBr.iY = output->iBounds.iBr.iY;
sl@0: 					}
sl@0: 				}
sl@0: 
sl@0: 			// Would any limits be exceeded by adding this group?
sl@0: 			if (param.iPosInText > end_char)
sl@0: 				break;
sl@0: 			if (new_advance > input.iMaxAdvance)
sl@0: 				break;
sl@0: 			if (vertical)
sl@0: 				{
sl@0: 				if (BoundsExceeded(input, param.iPen.iY, bounds.iBr.iY, bounds.iTl.iY))
sl@0: 					break;
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				if (BoundsExceeded(input, param.iPen.iX, bounds.iBr.iX, bounds.iTl.iX))
sl@0: 					break;
sl@0: 				}
sl@0: 
sl@0: 			if (aOutput)
sl@0: 				{
sl@0: 				aOutput->iChars = param.iPosInText;		// should this not be aOutput->iChars = param.iPosInText - input.iShartInputChar;?
sl@0: 				aOutput->iGlyphs += param.iOutputGlyphs;
sl@0: 				aOutput->iGroups = groups;
sl@0: 				aOutput->iSpaces = spaces;
sl@0: 				aOutput->iBounds = bounds;
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 		advance = new_advance;
sl@0: 		}
sl@0: 	if(shapeInfo.IsOpen())
sl@0: 		shapeInfo.Close();
sl@0: 	return advance;
sl@0: 	}
sl@0: 
sl@0: // These 3 functions should probably be moved to E32/Euser as part of TChar or
sl@0: // similar as there seem to be several local copies of similar functions in
sl@0: // various OS modules so we should remove duplication
sl@0: 
sl@0: TUint16 HighSurrogate(TUint aCode)
sl@0: 	{
sl@0: 	GDI_ASSERT_DEBUG(aCode  > 0xFFFF, EGdiPanic_InvalidInputParam);
sl@0: 	return STATIC_CAST(TUint16, 0xD7C0 + (aCode >> 10));
sl@0: 	}
sl@0: 	
sl@0: TUint16 LowSurrogate(TUint aCode)
sl@0: 	{
sl@0: 	GDI_ASSERT_DEBUG(aCode  > 0xFFFF, EGdiPanic_InvalidInputParam);
sl@0: 	return STATIC_CAST(TUint16, 0xDC00 | (aCode & 0x3FF));
sl@0: 	}
sl@0: 	
sl@0: TUint CombineSurrogates(TUint aHighSurrogate, TUint aLowSurrogate)
sl@0: 	{
sl@0: 	GDI_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xF800)), EGdiPanic_InvalidInputParam);
sl@0: 	GDI_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xFC00)), EGdiPanic_InvalidInputParam);
sl@0: 	GDI_ASSERT_DEBUG((0xDC00 == (aLowSurrogate & 0xFC00)), EGdiPanic_InvalidInputParam);
sl@0: 	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Overridable function innards of GetCharacterPosition and
sl@0: GetCharacterPosition2. It is generally not useful to override this function.
sl@0: @publishedAll
sl@0: @see GetCharacterPosition
sl@0: @see GetCharacterPosition2
sl@0: */
sl@0: EXPORT_C TBool CFont::DoGetCharacterPosition(TPositionParam& aParam) const
sl@0: 	{
sl@0: 	RShapeInfo shapeInfo;
sl@0: 	TBool r = GetCharacterPosition2(aParam, shapeInfo);
sl@0: 	if (shapeInfo.IsOpen())
sl@0: 		shapeInfo.Close();
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: // Find the script (and hence the correct process function) that any punctuation or digit may belong to
sl@0: LOCAL_C GlyphSelection::ProcessFunc FindContextualProcessFunc(RShapeInfo& aShapeInfo, const TGlyphSelectionState aGss)
sl@0: 	{
sl@0: 	GlyphSelection::ProcessFunc processFunc = CharacterToProcessFunction(aGss.iCodeChar);
sl@0: 	GlyphSelection::ProcessFunc contextProcessFunc = (GlyphSelection::ProcessFunc)aShapeInfo.GetContext();
sl@0: 	
sl@0: 	// If context or prevCode is NULL, use processFunc,
sl@0: 	// else use function of context or prevCode
sl@0: 	if ((aGss.iCodeChar.IsDigit() || aGss.iCodeChar.IsPunctuation()) && !QuoteOrBracketPair(aGss.iCodeChar) && processFunc!=GlyphSelector_SoftHyphen::Process)
sl@0: 		{
sl@0: 		// If context is not set, check the previous char for context.
sl@0: 		if (contextProcessFunc == NULL)
sl@0: 			{
sl@0: 			if (aGss.iParam.iPosInText > 0)
sl@0: 				{
sl@0: 				TChar prevCode = aGss.iText.Get(-1);
sl@0: 				GlyphSelection::ProcessFunc prevProcessFunc = CharacterToProcessFunction(prevCode);
sl@0: 				if (prevProcessFunc != NULL && (prevCode.IsAlpha() || prevProcessFunc != GlyphSelector_Default::Process))
sl@0: 					{
sl@0: 					aShapeInfo.SetContext((TAny *)prevProcessFunc);
sl@0: 					return prevProcessFunc;
sl@0: 					}
sl@0: 				}
sl@0: 			} 
sl@0: 		else 
sl@0: 			return contextProcessFunc;
sl@0: 		
sl@0: 		return processFunc;
sl@0: 		}
sl@0: 	
sl@0: 	// set the context with current processFunc only if current char is not ignored for context.
sl@0:  	if (processFunc != NULL && (aGss.iCodeChar.IsAlpha() || processFunc != GlyphSelector_Default::Process))
sl@0:  			aShapeInfo.SetContext((TAny *)processFunc);
sl@0:  	return processFunc;
sl@0: 	}
sl@0: 
sl@0: /** Takes Unicode text and produces the glyph cluster for the first character
sl@0: in that text plus any combining mark characters, or for the first indic
sl@0: syllable. It is responsible for contextual glyph selection, ligature creation
sl@0: and diacritic placement.
sl@0: 
sl@0: @param aParam
sl@0: 	The input/output parameter of the text/glyph data for the algorithm.
sl@0: @param aShapeInfo
sl@0: 	The function will cache "shaped" text (e.g. complex scripts such as
sl@0: 	Devanagari) here. aShapeInfo must be freshly-constructed or closed for each
sl@0: 	new piece of text in aParam.iText. If aParam.iText is unchanged between
sl@0: 	calls, aShapeInfo should be passed back in unchanged as well.
sl@0: @return
sl@0: 	ETrue if glyphs for supplied text have been produced, EFalse in failure.
sl@0: @see CFont::TPositionParam
sl@0: @publishedAll
sl@0: @released */
sl@0: EXPORT_C TBool CFont::GetCharacterPosition2(TPositionParam& aParam, RShapeInfo& aShapeInfo) const
sl@0: 	{
sl@0: 	GDI_ASSERT_DEBUG(aParam.iPosInText>=0, EGdiPanic_InvalidInputParam);
sl@0: 	GDI_ASSERT_DEBUG(aParam.iText.Ptr(), EGdiPanic_InvalidInputParam);
sl@0: 
sl@0: 	aParam.iOutputGlyphs = 0;
sl@0: 	TInt textLen = aParam.iText.Length();
sl@0: 	TBool outputOk = ETrue;
sl@0: 	TPoint penCopy = aParam.iPen;
sl@0: 
sl@0: 	// Verify input parameters are sane
sl@0: 	if (aParam.iPosInText >= textLen)
sl@0: 		return EFalse;
sl@0: 
sl@0: 	// Setup glyph selection algorithm data
sl@0: 	TUtf32Iterator textIter(aParam.iText.Ptr(), aParam.iText.Ptr()+textLen, aParam.iPosInText);
sl@0: 	if (textIter.AtEnd())
sl@0: 		{
sl@0: 		aParam.iPosInText = textIter.LengthToStart();
sl@0: 		return outputOk;
sl@0: 		}
sl@0: 
sl@0: 	// Process each character in the text in turn until we reach the end of
sl@0: 	// the iterator, the next base (non-mark/combining) character or reach
sl@0: 	// the limit in a glyph cluster.
sl@0: 	GlyphSelection::ProcessFunc firstProcessFn = 0;
sl@0: 	TGlyphSelectionState gss(textIter, this, aParam);
sl@0: 	do
sl@0: 		{
sl@0: 		// Retrieve character info for processing.
sl@0: 		gss.iCodePt = gss.iCodeChar = textIter.Get();
sl@0: 		gss.iCombCls = gss.iCodeChar.GetCombiningClass();
sl@0: 		gss.iCats = gss.iCodeChar.GetCategory();
sl@0: 		gss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;
sl@0: 		gss.iPen = TGlyphSelectionState::EPenAdvance_No;
sl@0: 
sl@0: 		// Find the correct processesing function for the script being used.
sl@0: 		// If gss.iCodePt is a strongly directional character, then simply map it in TTableEntry Table[]
sl@0: 		// and use the returned process function pointer.
sl@0: 		// If gss.iCodePt is a punctuation or a digit, then use a context character in the text (if
sl@0: 		// available) to find the contextual script being rendered and use its process function pointer.
sl@0: 		GlyphSelection::ProcessFunc processFn = FindContextualProcessFunc(aShapeInfo, gss);
sl@0: 
sl@0: 		if (!firstProcessFn)
sl@0: 			firstProcessFn = processFn;
sl@0: 
sl@0: 		if (processFn)
sl@0: 			{
sl@0: 			if (firstProcessFn == processFn)
sl@0: 				outputOk = processFn(gss, aShapeInfo);
sl@0: 			else
sl@0: 				break;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			// Table entry blank, unicode char to be skipped
sl@0: 			outputOk = ETrue;
sl@0: 			textIter.Next();
sl@0: 			gss.iClusterState = 
sl@0: 				(!textIter.AtEnd() &&
sl@0: 				((textIter.Get().GetCategory() & 0xF0) 
sl@0: 				== TChar::EMarkGroup)) ?
sl@0: 					TGlyphSelectionState::EGClusterNotComplete : TGlyphSelectionState::EGClusterComplete;
sl@0: 			}
sl@0: 
sl@0: 		// Abort if no class was available to process the character or if
sl@0: 		// processing failed.
sl@0: 		if (!outputOk)
sl@0: 			{
sl@0: 			aParam.iPosInText = textIter.LengthToStart();
sl@0: 			return outputOk;
sl@0: 			}
sl@0: 
sl@0: 		// Did the glyph selector that processed the character want the 
sl@0: 		// pen to advance?
sl@0: 		if (gss.iPen == TGlyphSelectionState::EPenAdvance_Yes)
sl@0: 			{
sl@0: 			aParam.iPen.iX += gss.iAdvance.iWidth;
sl@0: 			aParam.iPen.iY += gss.iAdvance.iHeight;
sl@0: 			gss.iPen = TGlyphSelectionState::EPenAdvance_No;
sl@0: 			}
sl@0: 
sl@0: 		// Here we assume the Process() methods have advanced the iterator as
sl@0: 		// they consume characters they handle so that it now points to the
sl@0: 		// character to process next time around the loop.
sl@0: 		}
sl@0: 	while (!textIter.AtEnd()	// We still have more text to process
sl@0: 		&& (gss.iClusterState == TGlyphSelectionState::EGClusterNotComplete) // Glyph cluster !complete
sl@0: 		&& (aParam.iOutputGlyphs < TPositionParam::EMaxOutputGlyphs)); // Room for another glyph entry
sl@0: 
sl@0: 	// If a complete glyph cluster has been identified then we should try to
sl@0: 	// compose it as fully as possible. Obviously, if it only contains one
sl@0: 	// character then it is already fully composed so we can ignore it.
sl@0: 	// Skip this if any language-specific processing has taken place.
sl@0: 	if (gss.iGlyphPostCombine == TGlyphSelectionState::EGPostCombine_Yes
sl@0: 		&& gss.iClusterState == TGlyphSelectionState::EGClusterComplete)
sl@0: 		{
sl@0: 		// Leave room to handle surrogates - Decompose() outputs UTF-16
sl@0: 		// The max that can come out of the previous stage is TPositionParam::EMaxOutputGlyphs
sl@0: 		// long with only one base char at the start. Even if that base char decomposed to the
sl@0: 		// max it could only be MaxOutputGlyphs long, giving a total of (2 * MaxOutputGlyphs)-1
sl@0: 		// Conceivably the use of surrogates throughout could double that when converting to UTF-16
sl@0: 		TBuf<TPositionParam::EMaxOutputGlyphs * 4> decomposeArray;
sl@0: 		TBool success = ETrue;
sl@0: 		// Go through the glyph cluster one char at a time
sl@0: 		for (TInt i = 0; i < aParam.iOutputGlyphs; i++)
sl@0: 			{
sl@0: 			TChar singleChar(aParam.iOutput[i].iCode);
sl@0: 			// If first character try to decompose it otherwise just take the character
sl@0: 			TBool decomposed = EFalse;
sl@0: 			TPtrC16 decomposition;
sl@0: 			if (i == 0)
sl@0: 				decomposed = singleChar.Decompose(decomposition);
sl@0: 			if (decomposed)
sl@0: 				{ // Pick up the sequence of characters
sl@0: 				decomposeArray.Append(decomposition);
sl@0: 				}
sl@0: 			else
sl@0: 				{ // Keep the original character
sl@0: 				if (singleChar > 0xFFFF)
sl@0: 					{ // Above the BMP so we need a surrogate pair for UTF-16
sl@0: 					// This calculation really ought to go into a separate routine - probably part of TChar
sl@0: 					decomposeArray.Append(HighSurrogate(singleChar));
sl@0: 					decomposeArray.Append(LowSurrogate(singleChar));
sl@0: 					}
sl@0: 				else
sl@0: 					{ // It's not a surrogate so we just need to cast it down (since it's safe)
sl@0: 					decomposeArray.Append(singleChar);
sl@0: 					}
sl@0: 				}
sl@0: 			// Guard against bad input overflowing the array and causing a panic
sl@0: 			if (decomposeArray.Length() > (TPositionParam::EMaxOutputGlyphs * 4) - 2)
sl@0: 				{ // too long to be a viable composition so don't try
sl@0: 				success = EFalse;
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		TUint composedChar = 0;
sl@0: 		TOpenFontCharMetrics metrics;
sl@0: 		TPositionParam::TOutput output;
sl@0: 		TSize advance; // gets initialized to 0,0
sl@0: 		if (success)
sl@0: 			{
sl@0: 			//Now try and compose the string to a single character
sl@0: 			success = TChar::Compose(composedChar, decomposeArray);
sl@0: 			}
sl@0: 		if (success)
sl@0: 			{
sl@0: 			// if single char is not in font or can't get char metrics for it
sl@0: 			// N.B. This will probably always return metrics because if the
sl@0: 			// char is not in the font this will usually return the substitute
sl@0: 			// "missing" glyph (and its metrics). There should be a function to
sl@0: 			// really tell you if a glyph is in the font - but there isn't.
sl@0: 			if (GetCharacterData(composedChar, metrics, output.iBitmap, output.iBitmapSize) == CFont::ENoCharacterData)
sl@0: 				success = EFalse;
sl@0: 			}
sl@0: 		if (success)
sl@0: 			{
sl@0: 			// We should replace the glyph cluster made from multiple chars
sl@0: 			// with the correct single char and fix up the rest of the output
sl@0: 			// parameters as well
sl@0: 			output.iCode = composedChar;
sl@0: 			// Set the glyph's bounds and record pen advancement.
sl@0: 			if (aParam.iDirection == CFont::EVertical)
sl@0: 				{
sl@0: 				metrics.GetVertBounds(output.iBounds);
sl@0: 				advance.iHeight = metrics.VertAdvance();
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				metrics.GetHorizBounds(output.iBounds);
sl@0: 				advance.iWidth = metrics.HorizAdvance();
sl@0: 				}
sl@0: 			// Adjust the glyph's bounding box to offset it from the pen
sl@0: 			// position (origin of drawing). For speed increment directly.
sl@0: 			output.iBounds.iTl.iX += penCopy.iX;
sl@0: 			output.iBounds.iBr.iX += penCopy.iX;
sl@0: 			output.iBounds.iTl.iY += penCopy.iY;
sl@0: 			output.iBounds.iBr.iY += penCopy.iY;
sl@0: 			// Set penCopy, the copy of aParam.iPen that we made
sl@0: 			penCopy.iX += advance.iWidth;
sl@0: 			penCopy.iY += advance.iHeight;
sl@0: 			// Overwrite the original output parameters for the glyph cluster
sl@0: 			// with the values for the single composed character
sl@0: 			aParam.iOutput[0] = output;
sl@0: 			aParam.iOutputGlyphs = 1;
sl@0: 			aParam.iPen = penCopy;	
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	// Exit routine with result and increment position in text to 
sl@0: 	// where we reached during processing to avoid any caller loops from 
sl@0: 	// infinite execution.
sl@0: 	aParam.iPosInText = textIter.LengthToStart();
sl@0: 	return outputOk;
sl@0: 	}
sl@0: 
sl@0: /** Gets the character metrics for a character.
sl@0: 	
sl@0: @param aCode The character code.
sl@0: @param aMetrics On return, contains the character bitmap.
sl@0: @param aBitmap On return, this points to NULL.
sl@0: @param aBitmapSize On return, this has a size of (0,0).
sl@0: @return ECharacterWidthOnly 
sl@0: */
sl@0: EXPORT_C CFont::TCharacterDataAvailability CFont::DoGetCharacterData(TUint aCode,TOpenFontCharMetrics& aMetrics,
sl@0: 		const TUint8*& aBinaryData,TSize& aBitmapSize) const
sl@0: 	{
sl@0: 	int width = CharWidthInPixels(aCode);
sl@0: 	aMetrics.SetHorizAdvance(width);
sl@0: 	aBinaryData = NULL;
sl@0: 	// For speed set to 0 directly rather than call SetSize()
sl@0: 	aBitmapSize.iWidth = 0;
sl@0: 	aBitmapSize.iHeight = 0;
sl@0: 
sl@0: 	/*
sl@0: 	Set the other metrics using the width and font metrics.
sl@0: 	This allows derived classes that don't override this function, like CInfoFont,
sl@0: 	to give usable results for TextWidthInPixels and MeasureText.
sl@0: 	*/
sl@0: 	aMetrics.SetWidth(width);
sl@0: 	int height = HeightInPixels();
sl@0: 	aMetrics.SetHeight(height);
sl@0: 	aMetrics.SetVertAdvance(height);
sl@0: 	aMetrics.SetHorizBearingX(0);
sl@0: 	aMetrics.SetHorizBearingY(AscentInPixels());
sl@0: 	aMetrics.SetVertBearingX(0);
sl@0: 	aMetrics.SetVertBearingY(0);
sl@0: 
sl@0: 	return CFont::ECharacterWidthOnly;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /** Determines if aLeftCharacter and aRightCharacter affect each other's
sl@0: contextual glyph form if placed next to each other. If either character
sl@0: is a combining character, EFalse will be returned, which is not generally
sl@0: useful information. Pass in base characters ignoring intervening combining
sl@0: characters.
sl@0: @param aLeftCharacter Unicode code for the character that stands on the left.
sl@0: @param aRightCharacter Unicode code for the character that stands on the right.
sl@0: @return EFalse if the characters do not affect the contextual glyphs that are
sl@0: be chosen when the two are rendered together, compared to being separated 
sl@0: (for example by a space). */	
sl@0: EXPORT_C TBool CFont::CharactersJoin(TInt aLeftCharacter, TInt aRightCharacter)
sl@0: 	{
sl@0: 	return GlyphSelector_Arabic::CharactersJoin(aLeftCharacter, aRightCharacter);
sl@0: 	}
sl@0: 
sl@0: /** API extension system that enables the caller to access a particular API
sl@0: extension function. N.B. Any overload of this function in a derived class
sl@0: should call its immediate parent implementation for any extension function Uid
sl@0: that it does not recognize and handle.
sl@0: @param aInterfaceId UID of the required extension function
sl@0: @param aParam Pointer to an arbitrary parameter block that can be used to
sl@0: provide and/or return information to/from the particular extension function,
sl@0: defaults to NULL.
sl@0: @return Integer return value from extension function
sl@0: @internalTechnology
sl@0: @released
sl@0: */
sl@0: EXPORT_C TInt CFont::DoExtendedFunction(TUid aFunctionId, TAny* /* aParam */) const
sl@0: 	{
sl@0: 	if (KFontCapitalAscent	== aFunctionId ||
sl@0: 		KFontMaxAscent		== aFunctionId)
sl@0: 		{
sl@0: 		return AscentInPixels();
sl@0: 		}
sl@0: 	else if (KFontStandardDescent	== aFunctionId ||
sl@0: 			 KFontMaxDescent		== aFunctionId)
sl@0: 		{
sl@0: 		return DescentInPixels();
sl@0: 		}
sl@0: 	else if (KFontLineGap == aFunctionId)
sl@0: 		{ // 1.2 of em height (rounded) is reasonable approximation of interline gap
sl@0: 		return (HeightInPixels() * 12 + 5) / 10;
sl@0: 		}
sl@0: 	return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TUid CFont::TypeUid() const
sl@0: 	{
sl@0: 	return DoTypeUid();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::HeightInPixels() const
sl@0: 	{
sl@0: 	return DoHeightInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::AscentInPixels() const
sl@0: 	{
sl@0: 	return DoAscentInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::DescentInPixels() const
sl@0: 	{
sl@0: 	return DoDescentInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::CharWidthInPixels(TChar aChar) const
sl@0: 	{
sl@0: 	return DoCharWidthInPixels(aChar);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::TextWidthInPixels(const TDesC& aText) const
sl@0: 	{
sl@0: 	return DoTextWidthInPixels(aText);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::BaselineOffsetInPixels() const
sl@0: 	{
sl@0: 	return DoBaselineOffsetInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::TextCount(const TDesC& aText,TInt aWidthInPixels) const
sl@0: 	{
sl@0: 	return DoTextCount(aText, aWidthInPixels);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::TextCount(const TDesC& aText, TInt aWidthInPixels, TInt& aExcessWidthInPixels) const
sl@0: 	{
sl@0: 	return DoTextCount(aText, aWidthInPixels, aExcessWidthInPixels);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::MaxCharWidthInPixels() const
sl@0: 	{
sl@0: 	return DoMaxCharWidthInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CFont::MaxNormalCharWidthInPixels() const
sl@0: 	{
sl@0: 	return DoMaxNormalCharWidthInPixels();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TFontSpec CFont::FontSpecInTwips() const
sl@0: 	{
sl@0: 	return DoFontSpecInTwips();
sl@0: 	}
sl@0: 	
sl@0: /** Gets the character metrics for a character.
sl@0: 	
sl@0: @param aCode The character code.
sl@0: @param aMetrics On return, contains the character bitmap.
sl@0: @param aBitmap On return, this points to NULL.
sl@0: @param aBitmapSize On return, this has a size of (0,0).
sl@0: @return ECharacterWidthOnly 
sl@0: */
sl@0: EXPORT_C CFont::TCharacterDataAvailability CFont::GetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics, const TUint8*& aBitmap, TSize& aBitmapSize) const
sl@0: 	{
sl@0: 	return DoGetCharacterData(aCode, aMetrics, aBitmap, aBitmapSize);
sl@0: 	}
sl@0: 
sl@0: /** Transforms one cluster of characters (base character plus combining marks,
sl@0: ligature or indic syllable) into one cluster of glyphs together with their
sl@0: positions. Repeated calls of this function (for the same input text) are
sl@0: considerably slower than repeated calls of GetCharacterPosition2 for Indic text
sl@0: (such as Hindi), as GetCharacterPosition2 can cache information between calls.
sl@0: @param aParam Input and output parameters
sl@0: @return True for success
sl@0: @see GetCharacterPosition2
sl@0: @publishedAll */
sl@0: EXPORT_C TBool CFont::GetCharacterPosition(TPositionParam& aParam) const
sl@0: 	{
sl@0: 	return DoGetCharacterPosition(aParam);
sl@0: 	}
sl@0: 
sl@0: /** Enables the caller to access a particular API
sl@0: extension function. N.B. Any overload of this function in a derived class
sl@0: should call its immediate parent implementation for any extension function UID
sl@0: that it does not recognize and handle.
sl@0: @param aFunctionId UID of the required extension function
sl@0: @param aParam Pointer to an arbitrary parameter block that can be used to
sl@0: provide and/or return information to/from the particular extension function,
sl@0: defaults to NULL.
sl@0: @return Integer return value from extension function 
sl@0: */
sl@0: EXPORT_C TInt CFont::ExtendedFunction(TUid aFunctionId, TAny* aParam) const
sl@0: 	{
sl@0: 	return DoExtendedFunction(aFunctionId, aParam);
sl@0: 	}
sl@0: 	
sl@0: EXPORT_C TInt CFont::TextWidthInPixels(const TDesC& aText,const TMeasureTextInput* aParam) const
sl@0: 	{
sl@0: 	TTextWidthInternal context;
sl@0: 	TTextWidthInternal* contextPtr = &context;
sl@0: 	contextPtr->iText.Set(aText);
sl@0: 	contextPtr->iParam.iStartInputChar = aParam->iStartInputChar;
sl@0: 	contextPtr->iParam.iEndInputChar = aParam->iEndInputChar;
sl@0: 	return DoExtendedFunction(KTextInContextWidthInPixelsUid, (TAny*)contextPtr);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Maps TLanguage to TScript.
sl@0: 
sl@0: EScriptOther represents languages not yet supported in KTScript2GlyphSample.
sl@0: This array does not handle ELangNone and ELangMaximum to save storage space.
sl@0: */
sl@0: const TInt GlyphSample::KTLanguage2TScript[] = 
sl@0: 	{
sl@0: 	EScriptNone,			// 00 ELangTest
sl@0: 	EScriptLatin,			// 01 ELangEnglish
sl@0: 	EScriptLatin,			// 02 ELangFrench
sl@0: 	EScriptLatin,			// 03 ELangGerman
sl@0: 	EScriptLatin,			// 04 ELangSpanish
sl@0: 	EScriptLatin,			// 05 ELangItalian
sl@0: 	EScriptLatin,			// 06 ELangSwedish
sl@0: 	EScriptLatin,			// 07 ELangDanish
sl@0: 	EScriptLatin,			// 08 ELangNorwegian
sl@0: 	EScriptLatin,			// 09 ELangFinnish
sl@0: 	EScriptLatin,			// 10 ELangAmerican
sl@0: 	EScriptLatin,			// 11 ELangSwissFrench
sl@0: 	EScriptLatin,			// 12 ELangSwissGerman
sl@0: 	EScriptLatin,			// 13 ELangPortuguese
sl@0: 	EScriptLatin,			// 14 ELangTurkish
sl@0: 	EScriptLatin,			// 15 ELangIcelandic
sl@0: 	EScriptCyrillic,		// 16 ELangRussian
sl@0: 	EScriptLatin,			// 17 ELangHungarian
sl@0: 	EScriptLatin,			// 18 ELangDutch
sl@0: 	EScriptLatin,			// 19 ELangBelgianFlemish
sl@0: 	EScriptLatin,			// 20 ELangAustralian
sl@0: 	EScriptLatin,			// 21 ELangBelgianFrench
sl@0: 	EScriptLatin,			// 22 ELangAustrian
sl@0: 	EScriptLatin,			// 23 ELangNewZealand
sl@0: 	EScriptLatin,			// 24 ELangInternationalFrench
sl@0: 	EScriptLatin,			// 25 ELangCzech
sl@0: 	EScriptLatin,			// 26 ELangSlovak
sl@0: 	EScriptLatin,			// 27 ELangPolish
sl@0: 	EScriptLatin,			// 28 ELangSlovenian
sl@0: 	EScriptHanIdeographs,	// 29 ELangTaiwanChinese
sl@0: 	EScriptHanIdeographs,	// 30 ELangHongKongChinese
sl@0: 	EScriptHanIdeographs,	// 31 ELangPrcChinese
sl@0: 	EScriptHanIdeographs,	// 32 ELangJapanese
sl@0: 	EScriptThai,			// 33 ELangThai
sl@0: 	EScriptLatin,			// 34 ELangAfrikaans
sl@0: 	EScriptLatin,			// 35 ELangAlbanian
sl@0: 	EScriptOther,			// 36 ELangAmharic
sl@0: 	EScriptArabic,			// 37 ELangArabic
sl@0: 	EScriptOther,			// 38 ELangArmenian
sl@0: 	EScriptOther,			// 39 ELangTagalog
sl@0: 	EScriptCyrillic,		// 40 ELangBelarussian
sl@0: 	EScriptOther,			// 41 ELangBengali
sl@0: 	EScriptCyrillic,		// 42 ELangBulgarian
sl@0: 	EScriptOther,			// 43 ELangBurmese
sl@0: 	EScriptLatin,			// 44 ELangCatalan
sl@0: 	EScriptLatin,			// 45 ELangCroatian
sl@0: 	EScriptLatin,			// 46 ELangCanadianEnglish
sl@0: 	EScriptLatin,			// 47 ELangInternationalEnglish
sl@0: 	EScriptLatin,			// 48 ELangSouthAfricanEnglish
sl@0: 	EScriptLatin,			// 49 ELangEstonian
sl@0: 	EScriptArabic,			// 50 ELangFarsi
sl@0: 	EScriptLatin,			// 51 ELangCanadianFrench
sl@0: 	EScriptLatin,			// 52 ELangScotsGaelic
sl@0: 	EScriptOther,			// 53 ELangGeorgian
sl@0: 	EScriptGreek,			// 54 ELangGreek
sl@0: 	EScriptGreek,			// 55 ELangCyprusGreek
sl@0: 	EScriptOther,			// 56 ELangGujarati
sl@0: 	EScriptHebrew,			// 57 ELangHebrew
sl@0: 	EScriptDevanagari,		// 58 ELangHindi
sl@0: 	EScriptLatin,			// 59 ELangIndonesian
sl@0: 	EScriptLatin,			// 60 ELangIrish
sl@0: 	EScriptLatin,			// 61 ELangSwissItalian
sl@0: 	EScriptOther,			// 62 ELangKannada
sl@0: 	EScriptCyrillic,		// 63 ELangKazakh
sl@0: 	EScriptOther,			// 64 ELangKhmer
sl@0: 	EScriptHanIdeographs,	// 65 ELangKorean
sl@0: 	EScriptOther,			// 66 ELangLao
sl@0: 	EScriptLatin,			// 67 ELangLatvian
sl@0: 	EScriptLatin,			// 68 ELangLithuanian
sl@0: 	EScriptCyrillic,		// 69 ELangMacedonian
sl@0: 	EScriptLatin,			// 70 ELangMalay
sl@0: 	EScriptOther,			// 71 ELangMalayalam
sl@0: 	EScriptDevanagari,		// 72 ELangMarathi
sl@0: 	EScriptLatin,			// 73 ELangMoldavian
sl@0: 	EScriptOther,			// 74 ELangMongolian
sl@0: 	EScriptLatin,			// 75 ELangNorwegianNynorsk
sl@0: 	EScriptLatin,			// 76 ELangBrazilianPortuguese
sl@0: 	EScriptOther,			// 77 ELangPunjabi
sl@0: 	EScriptLatin,			// 78 ELangRomanian
sl@0: 	EScriptCyrillic,		// 79 ELangSerbian
sl@0: 	EScriptOther,			// 80 ELangSinhalese
sl@0: 	EScriptLatin,			// 81 ELangSomali
sl@0: 	EScriptLatin,			// 82 ELangInternationalSpanish
sl@0: 	EScriptLatin,			// 83 ELangLatinAmericanSpanish
sl@0: 	EScriptLatin,			// 84 ELangSwahili
sl@0: 	EScriptLatin,			// 85 ELangFinlandSwedish
sl@0: 	EScriptNone,			// 86 ELangReserved1
sl@0: 	EScriptOther,			// 87 ELangTamil
sl@0: 	EScriptOther,			// 88 ELangTelugu
sl@0: 	EScriptOther,			// 89 ELangTibetan
sl@0: 	EScriptOther,			// 90 ELangTigrinya
sl@0: 	EScriptLatin,			// 91 ELangCyprusTurkish
sl@0: 	EScriptCyrillic,		// 92 ELangTurkmen
sl@0: 	EScriptCyrillic,		// 93 ELangUkrainian
sl@0: 	EScriptArabic,			// 94 ELangUrdu
sl@0: 	EScriptNone,			// 95 ELangReserved2
sl@0: 	EScriptLatin,			// 96 ELangVietnamese
sl@0: 	EScriptLatin,			// 97 ELangWelsh
sl@0: 	EScriptLatin,			// 98 ELangZulu
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: Maps TScript to glyph samples.
sl@0: 
sl@0: The order of samples definition has to follow the script order in TScript.
sl@0: 
sl@0: Supported scripts	Fonts used to experiment/determine glyph samples
sl@0: 
sl@0: Latin				Arial, Times, Century
sl@0: Greek				Ditto
sl@0: Cyrillic			Ditto
sl@0: Hebrew				Aharoni, David, FrankRuehl, Levenim MT, Miriam, Narkisim, Rod
sl@0: Arabic				Andalus, Arabic Transparent, Simplified Arabic, Traditional Arabic
sl@0: Devanagari			Mangal
sl@0: Thai				Angsana New, Browallia, Cordia New, DilleniaUPC, EucrosiaUPC,
sl@0: 					FreesiaUPC, IrisUPC, JasmineUPC, KodchiangUPC, LilyUPC
sl@0: HanIdeographs		Chinese	: SimSun, SimHei (Simplified) / MingLiU (Traditional)
sl@0: 					Japanese: MS Mincho, MS Gothic
sl@0: 					Korean	: Batang, Gulim
sl@0: */
sl@0: const TText* const GlyphSample::KTScript2GlyphSample[] = 
sl@0: 	{
sl@0: 	//
sl@0: 	// 02 EScriptLatin
sl@0: 	//
sl@0: 	//	0x00C0 - Ascent : Capital letter A with grave (Latin-1 Supplement)
sl@0: 	//	0x013A - Ascent : Small letter l with acute (Latin Extended A)
sl@0: 	//	0x1EA2 - Ascent : Capital letter A with hook above (Latin Extended Additional)
sl@0: 	//	0x00C7 - Descent: Capital letter C with cedilla (Latin-1 Supplement)
sl@0: 	//	0x0163 - Descent: Small letter t with cedilla (Latin Extended A)
sl@0: 	//
sl@0: 	_S("\x00C0\x013A\x1EA2\x00C7\x0163"),
sl@0: 	//
sl@0: 	// 03 EScriptGreek
sl@0: 	//
sl@0: 	//	0x03AA - Ascent : Capital letter iota with dialytika
sl@0: 	//	0x03AB - Ascent : Capital letter upsilon with dialytika
sl@0: 	//	0x03AE - Descent: Small letter eta with tonos
sl@0: 	//	0x03B2 - Descent: Small letter beta
sl@0: 	//	0x03C8 - Descent: Small letter psi
sl@0: 	//
sl@0: 	_S("\x03AA\x03AB\x03AE\x03B2\x03C8"),
sl@0: 	//
sl@0: 	// 04 EScriptCyrillic
sl@0: 	//
sl@0: 	//	0x0403 - Ascent : Capital letter gje
sl@0: 	//	0x0419 - Ascent : Capital letter short i
sl@0: 	//	0x0440 - Descent: Small letter er
sl@0: 	//	0x0452 - Descent: Small letter dje
sl@0: 	//	0x0458 - Descent: Small letter je
sl@0: 	//
sl@0: 	_S("\x0403\x0419\x0440\x0452\x0458"),
sl@0: 	//
sl@0: 	// 05 EScriptHebrew
sl@0: 	//
sl@0: 	//	0x05BE - Ascent : Punctuation maqaf
sl@0: 	//	0x05DC - Ascent : Letter lamed
sl@0: 	//	0x05B0 - Descent: Point sheva
sl@0: 	//	0x05BD - Descent: Point meteg
sl@0: 	//	0x05E7 - Descent: Letter qof
sl@0: 	//
sl@0: 	_S("\x05BE\x05DC\x05B0\x05BD\x05E7"),
sl@0: 	//
sl@0: 	// 06 EScriptArabic
sl@0: 	//
sl@0: 	// 	0x0670 - Ascent : Alef above (Arabic)
sl@0: 	// 	0x0671 - Ascent : Hamzat Wasl on Alef  isolated form
sl@0: 	// 	0x064D - Descent: Kasratan (Arabic)
sl@0: 	// 	0xFB7B - Descent: Final form of 0686
sl@0: 	// 	0xFBF2 - Descent: Final form of 064A
sl@0: 	//
sl@0: 	//PDEF120737: EScriptArabic value has been changed for this defect & tested using the font file provided by client (i.e. kamelion arabic font).
sl@0: 	//The client's font file can't be used for IPR reasons. Thus the test code to demonstrate this defect
sl@0: 	//is not added. Also, there was no other font file available that reproduces this defect. 
sl@0: 	//
sl@0: 	_S("\x0670\x0671\x064D\xFB7B\xFBF2"),
sl@0: 	//
sl@0: 	// 07 EScriptDevanagari
sl@0: 	//
sl@0: 	//	0x0914 - Ascent : Letter au
sl@0: 	//	0x0951 - Ascent : Stress sign udatta
sl@0: 	//	0x0941 - Descent: Vowel sign u
sl@0: 	//	0x0944 - Descent: Vowel sign rr
sl@0: 	//	0x0963 - Descent: Vowel sign vocalic ll
sl@0: 	//
sl@0: 	_S("\x0914\x0951\x0941\x0944\x0963"),
sl@0: 	//
sl@0: 	// 08 EScriptThai
sl@0: 	//
sl@0: 	//	0x0E49 - Ascent : Character mai tho
sl@0: 	//	0x0E4B - Ascent : Character mai chattawa
sl@0: 	//	0x0E0E - Descent: Character do chada
sl@0: 	//	0x0E24 - Descent: Character ru
sl@0: 	//	0x0E39 - Descent: Character sara uu
sl@0: 	//
sl@0: 	_S("\x0E49\x0E4B\x0E0E\x0E24\x0E39"),
sl@0: 	//
sl@0: 	// 09 EScriptHanIdeographs
sl@0: 	//
sl@0: 	//	0x1100 - Ascent/Descent: Korean
sl@0: 	//	0x4E1C - Ascent/Descent: Chinese Simplified
sl@0: 	//	0x5283 - Ascent/Descent: Japanese
sl@0: 	//	0x758A - Ascent : Chinese Traditional
sl@0: 	//	0x7BEA - Descent: Chinese Traditional
sl@0: 	//
sl@0: 	_S("\x1100\x4E1C\x5283\x758A\x7BEA"),
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: Maps a TLanguage type to the TScript type.
sl@0: @internalTechnology
sl@0: @param aLanguage The language.
sl@0: @return A TInt representing the script, or 
sl@0: EScriptNone if its not defined for aLanguage.
sl@0: */
sl@0: EXPORT_C TInt GlyphSample::TLanguage2TScript(TLanguage aLanguage)
sl@0: 	{
sl@0: 	if (ELangNone == aLanguage || ELangMaximum == aLanguage || aLanguage >= (sizeof(KTLanguage2TScript)/sizeof(KTLanguage2TScript[0])))
sl@0: 		{
sl@0: 		return EScriptNone;
sl@0: 		}
sl@0: 	return KTLanguage2TScript[aLanguage];
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Maps a TScript type to some glyph samples which are stored as Unicode.
sl@0: @internalTechnology
sl@0: @param aScript The script.
sl@0: @return A TPtrC pointing to the first glyph sample,
sl@0: or empty if no samples is defined for aScript.
sl@0: */
sl@0: EXPORT_C const TPtrC GlyphSample::TScript2GlyphSample(TInt aScript)
sl@0: 	{
sl@0: 	if (EScriptOther >= aScript)
sl@0: 		{
sl@0: 		return TPtrC();
sl@0: 		}
sl@0: 	// -3 to offset EScriptDefault, EScriptNone and EScriptOther
sl@0: 	// being the first three elements in TScript.
sl@0: 	return TPtrC(KTScript2GlyphSample[aScript - 3]);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: EXPORT_C RFontTable::RFontTable():iTableContent(0), iLength(0),
sl@0:         iFont(NULL), iTag(0)
sl@0:     {
sl@0:     // a null constructor.
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt
sl@0: RFontTable::Open(CFont& aFont, TUint32 aTag) 
sl@0:     {
sl@0:     TGetFontTableParam param;
sl@0:     param.iTag = aTag;
sl@0:     
sl@0:     // remember the parameters, to be used when releasing the font table.
sl@0:     iFont = &aFont;
sl@0:     iTag = aTag;
sl@0:     
sl@0:     TInt ret = aFont.ExtendedFunction(KFontGetFontTable, (TAny *)&param);
sl@0:     if (KErrNone == ret)
sl@0:         {
sl@0:         iTableContent = (TAny *)param.iContent;
sl@0:         iLength = param.iLength;
sl@0:         }
sl@0:     return ret;
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt 
sl@0: RFontTable::TableLength() const
sl@0:     {
sl@0:     return iLength;
sl@0:     }
sl@0: 
sl@0: EXPORT_C const TUint8*
sl@0: RFontTable::TableContent() const 
sl@0:     {
sl@0:     return (TUint8*)iTableContent;
sl@0:     }
sl@0: 
sl@0: EXPORT_C void
sl@0: RFontTable::Close()
sl@0:     {
sl@0:     if (NULL != iFont)
sl@0:         {
sl@0:         (void)iFont->ExtendedFunction(KFontReleaseFontTable, (TAny *)&iTag);
sl@0:         }
sl@0:     iTableContent = 0;
sl@0:     iLength = 0;
sl@0:     iFont = NULL;
sl@0:     iTag = 0;
sl@0:     }
sl@0: 
sl@0: EXPORT_C 
sl@0: RGlyphOutlineIterator::RGlyphOutlineIterator():iOutlines(0), iLengths(0), 
sl@0:     iCursor(-1), iCount(0), iFont(NULL), iCodes(NULL), iHinted(EFalse)
sl@0:     {
sl@0:     // a null constructor.
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt
sl@0: RGlyphOutlineIterator::Open(CFont& aFont, const TUint* aCodes, TInt aCount, TBool aHinted) 
sl@0:     {
sl@0:     if (NULL == aCodes || 0 == aCount)
sl@0:         {
sl@0:         return KErrArgument;
sl@0:         }
sl@0:     TGetGlyphOutlineParam param;
sl@0:     iLengths = (TInt *)User::Alloc(sizeof(TInt) * aCount);
sl@0:     if (NULL == iLengths) 
sl@0:         {
sl@0:         return KErrNoMemory;
sl@0:         }
sl@0:     iOutlines = (TAny **)User::Alloc(sizeof(TAny *) * aCount);
sl@0:     if (NULL == iOutlines)
sl@0:         {
sl@0:         User::Free(iLengths);
sl@0:         iLengths = NULL;
sl@0:         return KErrNoMemory;
sl@0:         }
sl@0:     
sl@0:     param.iLengths = iLengths; 
sl@0:     param.iCount = aCount;
sl@0:     param.iCodes = aCodes; 
sl@0:     param.iHinted = aHinted;
sl@0:     param.iOutlines = iOutlines; 
sl@0:         
sl@0:     /* information needed in Close() */
sl@0:     iCodes = (TUint *)User::Alloc(sizeof(TUint) * aCount);
sl@0:     if (NULL == iCodes) 
sl@0:         {
sl@0:         User::Free(iLengths);
sl@0:         User::Free(iOutlines);
sl@0:         iLengths = NULL;
sl@0:         iOutlines = NULL;
sl@0:         return KErrNoMemory;
sl@0:         }
sl@0:     Mem::Copy(iCodes, aCodes, aCount*sizeof(TUint));
sl@0:     iFont = &aFont;
sl@0:     iHinted = aHinted;
sl@0:     iCount = aCount;
sl@0:     
sl@0:     TInt ret = aFont.ExtendedFunction(KFontGetGlyphOutline, (TAny *)&param);
sl@0:     if (KErrNone != ret)
sl@0:         {
sl@0:         User::Free(iLengths);
sl@0:         User::Free(iOutlines);
sl@0:         User::Free(iCodes);
sl@0:         iLengths = NULL;
sl@0:         iOutlines = NULL;
sl@0:         iCodes = NULL;
sl@0:         iFont = NULL;
sl@0:         }
sl@0:     else 
sl@0:         {
sl@0:         iCursor = 0;
sl@0:         }
sl@0: 
sl@0:     return ret;
sl@0:     }
sl@0: 
sl@0: EXPORT_C const TUint8*
sl@0: RGlyphOutlineIterator::Outline() const
sl@0:     {
sl@0:     GDI_ASSERT_ALWAYS(iCursor >= 0, EGdiPanic_Unknown);
sl@0:     
sl@0:     if (iLengths[iCursor] < 0) 
sl@0:         {
sl@0:         return NULL;
sl@0:         }
sl@0:     else 
sl@0:         {
sl@0:         return (const TUint8*)iOutlines[iCursor];
sl@0:         }
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt 
sl@0: RGlyphOutlineIterator::OutlineLength() const 
sl@0:     {
sl@0:     GDI_ASSERT_ALWAYS(iCursor >= 0, EGdiPanic_Unknown);
sl@0:     
sl@0:     if (iLengths[iCursor] < 0) 
sl@0:         {
sl@0:         return KErrGeneral;
sl@0:         }
sl@0:     else 
sl@0:         {
sl@0:         return iLengths[iCursor];
sl@0:         }
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt
sl@0: RGlyphOutlineIterator::Next()
sl@0:     {
sl@0:     if (iCursor >= 0 && iCursor < iCount-1) 
sl@0:         {
sl@0:         ++iCursor;
sl@0:         return KErrNone;
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         iCursor = -1; 
sl@0:         // if the iterator goes beyond the last element [when
sl@0:         // Next() returns KErrNotFound], the next call
sl@0:         // to Outline() or OutlineLength() will panic.
sl@0:         
sl@0:         return KErrNotFound;
sl@0:         }
sl@0:     }
sl@0: 
sl@0: EXPORT_C void
sl@0: RGlyphOutlineIterator::Close()
sl@0:     {
sl@0:     TReleaseGlyphOutlineParam param;
sl@0:     param.iCount = iCount;
sl@0:     param.iHinted = iHinted;
sl@0:     param.iCodes = iCodes;
sl@0:     
sl@0:     if (NULL != iFont)
sl@0:         {
sl@0:         iFont->ExtendedFunction(KFontReleaseGlyphOutline, (TAny *)&param);
sl@0:         }
sl@0:     
sl@0:     iFont = NULL;
sl@0:     iCount = 0;
sl@0:     User::Free(iLengths);
sl@0:     iLengths = NULL;
sl@0:     iCursor = -1;
sl@0:     User::Free(iCodes);
sl@0:     iCodes = NULL;
sl@0:     User::Free(iOutlines);
sl@0:     iOutlines = NULL;
sl@0:     }