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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <e32std.h>

 #include <e32svr.h>

 #include "LineBreak.h"

 #include "LineBreakImp.h"

 #include "GlyphSel.h"

 const TText16 KThaiCodePageStart = 0x0E00;

 const TText16 KThaiCodePageEnd   = 0x0E5C;

 const TUint KNumThaiCharacters = KThaiCodePageEnd - KThaiCodePageStart;

 /**

  Ecanpsulates rules for when Thai character sequence line breaking.

 @internalComponent

 */

 class ThaiLinebreakRules

 	{

 public:

 	enum TCharClassification

 		{

 		EOutOfRange,

 		EConsOAng,

 		EConsYoYak,

 		EConsHoHip,

 		EConsWoWean,

 		EConsDigraph,

 		EConsOther,

 		EPostVowelA,

 		EPostVowelAA,

 		EPostVowelOther,

 		EPreVowel,

 		EDepMaiHanAkat,

 		EDepSaraI,

 		EDepOther,

 		// marker for end

 		EMaxClassification

 		};

 	enum

 		{

 		KOutOfRangeFlag = 1 << EOutOfRange,

 		KConsOAngFlag = 1 << EConsOAng,

 		KConsYoYakFlag = 1 << EConsYoYak,

 		KConsHoHipFlag = 1 << EConsHoHip,

 		KConsWoWeanFlag = 1 << EConsWoWean,

 		KConsDigraphFlag = 1 << EConsDigraph,

 		KConsOtherFlag = 1 << EConsOther,

 		KPostVowelAFlag = 1 << EPostVowelA,

 		KPostVowelAAFlag = 1 << EPostVowelAA,

 		KPostVowelOtherFlag = 1 << EPostVowelOther,

 		KPreVowelFlag = 1 << EPreVowel,

 		KDepMaiHanAkatFlag = 1 << EDepMaiHanAkat,

 		KDepSaraIFlag = 1 << EDepSaraI,

 		KDepOtherFlag = 1 << EDepOther,

 		KSpecialDepFlags = KDepMaiHanAkatFlag | KDepSaraIFlag,

 		KPostVowelFlags = KPostVowelAFlag | KPostVowelAAFlag | KPostVowelOtherFlag,

 		KConsFlags = KConsOtherFlag | KConsDigraphFlag | KConsWoWeanFlag

 			| KConsHoHipFlag | KConsYoYakFlag | KConsOAngFlag,

 		KAllFlags = KOutOfRangeFlag | KConsOAngFlag | KConsYoYakFlag

 			| KConsHoHipFlag | KConsWoWeanFlag | KConsDigraphFlag

 			| KConsOtherFlag | KPostVowelAFlag | KPostVowelAAFlag

 			| KPostVowelOtherFlag | KPreVowelFlag | KDepMaiHanAkatFlag

 			| KDepSaraIFlag | KDepOtherFlag

 		};

 	/** Returns the Thai linebreaking class of the character. */

 	static TCharClassification Class(TInt aChar);

 	/** Returns true if aChar is a combining character according to aBreaker. */

 	static TBool IsCombiningChar(TInt aChar, const MLineBreaker& aBreaker);

 	/** Returns the Thai linebreaking class of the character at (*aChar),

 	searching backwards for the base character if it is foreign and of type CM.

 	@param aChar The position of the character within the string.

 	@param aStart The start of the string.

 	@param aBreaker The line breaker to query for line breaking class.

 	*/

 	static TCharClassification DerivedClass(const TText* aChar,

 		const TText* aStart, const MLineBreaker& aBreaker);

 	/**

 	 Gets the line break rule for the previous and current character pair

 	@param aPrevClass Class of the previous character.

 	@param aClass Class of the current character.

 	@return the rule code corresponding to the input pair.

 	*/

 	static TBool BreakAllowedBetween(

 		TCharClassification aPrevClass, TCharClassification aClass);

 	/** Returns whether a line break is allowed before the SA character at

 	(*aChar).

 	@param aChar The position of the character within the string.

 	@param aStart The start of the string.

 	@param aBreaker The line breaker to query for line breaking class.

 	*/

 	static TBool BreakAllowedAt(const TText* aChar,

 		const TText* aStart, const MLineBreaker& aBreaker);

 	/**

 	 Classification of each character

 	*/

 	static const TUint8 KCharClassifications[KNumThaiCharacters];

 	/**

 	 Rules table of prev to next character

 	*/

 	static const TUint32 KRules[EMaxClassification];

 	};

 const TUint8 ThaiLinebreakRules::KCharClassifications[KNumThaiCharacters] = 

 	{

 	EOutOfRange,	// 0x0E00

 	EConsOther,		// 0x0E01

 	EConsOther,		// 0x0E02

 	EConsOther,		// 0x0E03

 	EConsOther,		// 0x0E04

 	EConsOther,		// 0x0E05

 	EConsOther,		// 0x0E06

 	EConsDigraph,	// 0x0E07

 	EConsOther,		// 0x0E08

 	EConsOther,		// 0x0E09

 	EConsOther,		// 0x0E0A

 	EConsOther,		// 0x0E0B

 	EConsOther,		// 0x0E0C

 	EConsOther,		// 0x0E0D

 	EConsOther,		// 0x0E0E

 	EConsOther,		// 0x0E0F

 	EConsOther,		// 0x0E10

 	EConsOther,		// 0x0E11

 	EConsOther,		// 0x0E12

 	EConsOther,		// 0x0E13

 	EConsOther,		// 0x0E14

 	EConsOther,		// 0x0E15

 	EConsOther,		// 0x0E16

 	EConsOther,		// 0x0E17

 	EConsOther,		// 0x0E18

 	EConsDigraph,	// 0x0E19

 	EConsOther,		// 0x0E1A

 	EConsOther,		// 0x0E1B

 	EConsOther,		// 0x0E1C

 	EConsOther,		// 0x0E1D

 	EConsOther,		// 0x0E1E

 	EConsOther,		// 0x0E1F

 	EConsOther,		// 0x0E20

 	EConsDigraph,	// 0x0E21

 	EConsYoYak,		// 0x0E22

 	EConsDigraph,	// 0x0E23

 	EConsOther,		// 0x0E24

 	EConsDigraph,	// 0x0E25

 	EConsOther,		// 0x0E26

 	EConsWoWean,	// 0x0E27

 	EConsOther,		// 0x0E28

 	EConsOther,		// 0x0E29

 	EConsOther,		// 0x0E2A

 	EConsHoHip,		// 0x0E2B

 	EConsOther,		// 0x0E2C

 	EConsOAng,		// 0x0E2D

 	EConsOther,		// 0x0E2E

 	EOutOfRange,	// 0x0E2F

 	EPostVowelA,	// 0x0E30

 	EDepMaiHanAkat,	// 0x0E31

 	EPostVowelAA,	// 0x0E32

 	EPostVowelOther,// 0x0E33

 	EDepSaraI,		// 0x0E34

 	EDepOther,		// 0x0E35

 	EDepOther,		// 0x0E36

 	EDepOther,		// 0x0E37

 	EDepOther,		// 0x0E38

 	EDepOther,		// 0x0E39

 	EDepOther,		// 0x0E3A

 	EOutOfRange,	// 0x0E3B

 	EOutOfRange,	// 0x0E3C

 	EOutOfRange,	// 0x0E3D

 	EOutOfRange,	// 0x0E3E

 	EOutOfRange,	// 0x0E3F

 	EPreVowel,		// 0x0E40

 	EPreVowel,		// 0x0E41

 	EPreVowel,		// 0x0E42

 	EPreVowel,		// 0x0E43

 	EPreVowel,		// 0x0E44

 	EPostVowelOther,// 0x0E45

 	EOutOfRange,	// 0x0E46

 	EDepOther,		// 0x0E47

 	EDepOther,		// 0x0E48

 	EDepOther,		// 0x0E49

 	EDepOther,		// 0x0E4A

 	EDepOther,		// 0x0E4B

 	EDepOther,		// 0x0E4C

 	EDepOther,		// 0x0E4D

 	EDepOther,		// 0x0E4E

 	EOutOfRange,	// 0x0E4F

 	EOutOfRange,		// 0x0E50

 	EOutOfRange,		// 0x0E51

 	EOutOfRange,		// 0x0E52

 	EOutOfRange,		// 0x0E53

 	EOutOfRange,		// 0x0E54

 	EOutOfRange,		// 0x0E55

 	EOutOfRange,		// 0x0E56

 	EOutOfRange,		// 0x0E57

 	EOutOfRange,		// 0x0E58

 	EOutOfRange,		// 0x0E59

 	EOutOfRange,		// 0x0E5A

 	EOutOfRange			// 0x0E5B

 	};

 const TUint32 KNormalBreaksBeforeCons =

 	ThaiLinebreakRules::KPreVowelFlag

 	| ThaiLinebreakRules::KConsOtherFlag

 	| ThaiLinebreakRules::KConsDigraphFlag

 	| ThaiLinebreakRules::KConsHoHipFlag

 	| ThaiLinebreakRules::KOutOfRangeFlag;

 const TUint32 KNormalBreaksBeforePostVowel =

 	ThaiLinebreakRules::KPreVowelFlag

 	| ThaiLinebreakRules::KPostVowelFlags

 	| ThaiLinebreakRules::KConsFlags

 	| ThaiLinebreakRules::KOutOfRangeFlag;

 const TUint32 ThaiLinebreakRules::KRules[EMaxClassification] =

 	{

 	/* Prev Char EOutOfRange */

 	KAllFlags - KOutOfRangeFlag,

 	/* Prev Char EConsOAng */

 	KNormalBreaksBeforeCons,

 	/* Prev Char EConsYoYak */

 	KNormalBreaksBeforeCons,

 	/* Prev Char EConsHoHip */

 	KNormalBreaksBeforeCons - KConsDigraphFlag,

 	/* Prev Char EConsWoWean */

 	KNormalBreaksBeforeCons - KConsDigraphFlag - KConsHoHipFlag,

 	/* Prev Char EConsDigraph */

 	KNormalBreaksBeforeCons,

 	/* Prev Char EConsOther */

 	KNormalBreaksBeforeCons,

 	/* Prev Char EPostVowelA */

 	KNormalBreaksBeforePostVowel,

 	/* Prev Char EPostVowelAA */

 	KNormalBreaksBeforePostVowel - KPostVowelAFlag,

 	/* Prev Char EPostVowelOther */

 	KNormalBreaksBeforePostVowel,

 	/* Prev Char EPreVowel */

 	KPreVowelFlag | KPostVowelFlags | KOutOfRangeFlag,

 	/* Prev Char EDepMaiHanAkat */

 	KSpecialDepFlags | KPreVowelFlag | KPostVowelAAFlag

 		| KPostVowelAFlag | KOutOfRangeFlag,

 	/* Prev Char EDepSaraI */

 	KSpecialDepFlags | KPreVowelFlag | KPostVowelAAFlag

 		| KPostVowelAFlag | KOutOfRangeFlag,

 	/* Prev Char EDepOther */

 	KSpecialDepFlags | KPreVowelFlag | KPostVowelAAFlag

 		| KPostVowelAFlag | KConsOtherFlag | KConsDigraphFlag

 		| KConsWoWeanFlag | KConsHoHipFlag | KOutOfRangeFlag

 	};

 ThaiLinebreakRules::TCharClassification ThaiLinebreakRules::Class(TInt a)

     {

 	return static_cast<TCharClassification>(

 		(KThaiCodePageStart <= a && a < KThaiCodePageEnd) ?

 			KCharClassifications[a - KThaiCodePageStart] :

 			EOutOfRange);

     }

 TBool ThaiLinebreakRules::IsCombiningChar(TInt aChar,

 	const MLineBreaker& aBreaker)

 	{

 	TUint dummy1, dummy2;

 	return aBreaker.LineBreakClass(aChar, dummy1, dummy2) == MLineBreaker::ECmLineBreakClass;

 	}

 ThaiLinebreakRules::TCharClassification ThaiLinebreakRules::DerivedClass(

 	const TText* aChar, const TText* aStart, const MLineBreaker& aBreaker)

 	{

 	ThaiLinebreakRules::TCharClassification c = Class(*aChar);

 	while (c == EOutOfRange && aChar != aStart

 		&& IsCombiningChar(*aChar, aBreaker))

 		{

 		--aChar;

 		c = Class(*aChar);

 		}

 	return c;

 	}

 TBool ThaiLinebreakRules::BreakAllowedBetween(

 	ThaiLinebreakRules::TCharClassification aClass,

 	ThaiLinebreakRules::TCharClassification aNextClass)

 	{

 	return KRules[aClass] & (1 << aNextClass);

 	}

 TBool ThaiLinebreakRules::BreakAllowedAt(const TText* aChar,

 	const TText* aStart, const MLineBreaker& aBreaker)

 	{

 	__ASSERT_DEBUG(aStart < aChar, User::Invariant());

 	TCharClassification c = Class(*aChar);

 	if (c == EOutOfRange && IsCombiningChar(*aChar, aBreaker))

 		return EFalse;

 	return BreakAllowedBetween(DerivedClass(aChar - 1, aStart, aBreaker), c);

 	}

 /**

  Returns whether a line break is possible within a run of characters all having

  the class ESaLineBreakClass (Complex content). Languages with Unicocde

  characters having such a class include: Thai, Lao, Myanmar and Khmer. This

  default implementation of the GetLineBreakInContext() method only supports the

  Thai script. Breaks are determined in Thai based on a simple understanding of

  syllable boundaries. When characters from the other unsupported Sa class

  languages are found the method exits with EFalse.

 @param aText

  The text to be searched, which is a contiguous run of characters of class SA

  (or CM attatched to SA). The break position may be restricted further by

  aMinBreakPos and aMaxBreakPos, but more text is provided for extra context

  should it be needed.

 @param aMinBreakPos

  The start of the text to be considered for line breaks.

 @param aMaxBreakPos

  The end of the text to be considered for line breaks.

 @param aForwards

  ETrue if aBreakPos is to be set with the first legal break position,

  EFalse if aBreakPos is to be set with the last legal break position.

 @param aBreakPos

  If break position found on exit its value is >= Min and <= Max 

  positions supplied.

 @return TBool

  ETrue if and only if a legal break was found, EFalse otherwise.

 @publishedAll

 @released

 */

 EXPORT_C TBool MLineBreaker::GetLineBreakInContext(const TDesC16& aText,

 		TInt aMinBreakPos, TInt aMaxBreakPos, TBool aForwards,

 		TInt& aBreakPos) const

 	{

 	__ASSERT_DEBUG (0 <= aMinBreakPos && aMaxBreakPos <= aText.Length(), 

 		Panic(ELineBreakPanic_InvalidInputParam));

 	TInt length = aText.Length();

 	if (aMinBreakPos < 1)

 		aMinBreakPos = 1;

 	if (length - 1 < aMaxBreakPos)

 		aMaxBreakPos = length - 1;

 	if (aMaxBreakPos < aMinBreakPos)

 		return EFalse;

 	const TText16* text = aText.Ptr();

 	if (*text == KZeroWidthSpace)

 		{

 		aBreakPos = aMinBreakPos;

 		return ETrue;

 		}

 	else if (*(text+length-1) == KZeroWidthSpace)

 		return EFalse;

 	TInt start = aForwards? aMinBreakPos : aMaxBreakPos;

 	TInt end = aForwards? aMaxBreakPos + 1 : aMinBreakPos - 1;

 	TInt direction = aForwards? 1 : -1;

 	for (TInt i = start; i != end; i += direction)

 		{

 		if (ThaiLinebreakRules::BreakAllowedAt(text + i, text, *this))

 			{

 			aBreakPos = i;

 			return ETrue;

 			}

 		}

 	return EFalse;

 	}