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

/**

 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.

	{

	}

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;

		}