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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <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;

	}