/*

* 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

* which accompanies this distribution, and is available

* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

* Definitions for bidirectional text reordering.

* 

*

*/

#ifndef BIDI_H_

#define BIDI_H_

#include <e32std.h>

class RWriteStream;

class RReadStream;

class TBidirectionalState

/** 

The bidirectional state class. 

This class contains functions that implement the Unicode Bidirectional Algorithm, 

which changes text from logical order to display order for the correct display 

of right-to-left scripts, like Arabic and Hebrew. A TBidirectionalState object 

carries the embedding level and stack from one line to the next. On construction 

it is in its 'start of paragraph' state. 

@publishedAll

@released

*/

	{

public:

	class TRunInfo

	/** 

	Information about a run of characters with the same bidirectional 

	category. 

	An array of these representing a line is passed into, and reordered by, 

	ReorderLine(). 

	@publishedAll

	@released

	*/

		{

		public:

		/** Category of a run of text: passed to ReorderLine(); these are 

		passed in as TChar::TBdCategory values but are modified for internal 

		use. */

		TUint iCategory;		

		/** Embedding level of this run: used internally by ReorderLine(). */

		TUint8 iEmbeddingLevel;	

		/** Resolved direction of this run: 0 for left to right, 1 for right 

		to left. */

		TUint8 iDirection;		

		/** Index of this run after reordering. */

		TInt iIndex;			

		/** Start of text; returned by ReorderText(). */

		TInt iStart;			

		/** Length of text; returned by ReorderText(). */

		TInt iLength;			

		};

	IMPORT_C TBidirectionalState();

	IMPORT_C void ReorderLine(TRunInfo* aRunInfo,TInt aRuns,TBool aParStart,TBool aParEnd,TBool aParRightToLeft,

					 TChar::TBdCategory aNextCategory,TChar::TBdCategory aNextStrongCategory,

					 TBool& aVisualEndIsAmbiguous);

	IMPORT_C void ReorderLine(TRunInfo* aRunInfo,TInt aRuns,TBool aParStart,TBool aParEnd,TBool aParRightToLeft,

					 TChar::TBdCategory aNextCategory,TChar::TBdCategory aNextStrongCategory);

	IMPORT_C static TInt ReorderText(const TText* aText,TInt aLength,TBool aParRightToLeft,TText*& aNewText);

	IMPORT_C static void ReverseGroups(TText* aStart,TInt aLength);

	IMPORT_C void Reset();

	IMPORT_C TBool IsDefault() const;

	IMPORT_C TBool operator==(const TBidirectionalState& aState) const;

	IMPORT_C void ExternalizeL(RWriteStream& aDest);

	IMPORT_C void InternalizeL(RReadStream& aSource);

	TBool ParRightToLeft() const { return iStack[0].iEmbeddingLevel & 1; }

private:

	// Bidirectional categories coded as bit flags

	enum TCategory

		{

		ELeftToRight = 1 << TChar::ELeftToRight, 

		ELeftToRightEmbedding = 1 << TChar::ELeftToRightEmbedding,

		ELeftToRightOverride = 1 << TChar::ELeftToRightOverride,

		ERightToLeft = 1 << TChar::ERightToLeft,

		ERightToLeftArabic = 1 << TChar::ERightToLeftArabic,

		ERightToLeftEmbedding = 1 << TChar::ERightToLeftEmbedding, 

		ERightToLeftOverride = 1 << TChar::ERightToLeftOverride,

		EPopDirectionalFormat = 1 << TChar::EPopDirectionalFormat, 

		EEuropeanNumber = 1 << TChar::EEuropeanNumber, 

		EEuropeanNumberSeparator = 1 << TChar::EEuropeanNumberSeparator, 

		EEuropeanNumberTerminator = 1 << TChar::EEuropeanNumberTerminator, 

		EArabicNumber = 1 << TChar::EArabicNumber,

		ECommonNumberSeparator = 1 << TChar::ECommonNumberSeparator, 

		ENonSpacingMark = 1 << TChar::ENonSpacingMark, 

		EBoundaryNeutral = 1 << TChar::EBoundaryNeutral, 

		EParagraphSeparator = 1 << TChar::EParagraphSeparator, 

		ESegmentSeparator = 1 << TChar::ESegmentSeparator, 

		EWhitespace = 1 << TChar::EWhitespace, 

		EOtherNeutral = 1 << TChar::EOtherNeutral,

		// useful groups

		EBdControlsGroup = ELeftToRightEmbedding | ERightToLeftEmbedding |

						   ELeftToRightOverride | ERightToLeftOverride | EPopDirectionalFormat,

		ELeftToRightGroup = ELeftToRight | EEuropeanNumber | ELeftToRightOverride | ELeftToRightEmbedding,

		ERightToLeftGroup = ERightToLeft | EArabicNumber | ERightToLeftArabic | ERightToLeftOverride |

							ERightToLeftEmbedding,

		EStrongGroup = ELeftToRightEmbedding | ERightToLeftEmbedding

			| ELeftToRightOverride | ERightToLeftOverride

			| ELeftToRight | ERightToLeft | ERightToLeftArabic,

		ENoCategory = 0

		};

	enum

		{

		EMaxExplicitLevel = 61,

		EMaxLevel = 63,

		EMaxStackLevels = 62

		};

	enum TOverrideState

		{

		ENoOverrideState = 0,

		ELeftToRightOverrideState = ELeftToRightOverride,

		ERightToLeftOverrideState = ERightToLeftOverride

		};

	class TStackItem

		{

	public:

		TUint8 iEmbeddingLevel;			// embedding level

		TOverrideState iOverrideState;	// directional override state

		TCategory iStartCategory;		// category that started this level; EOtherNeutral if none

		};

public:

	/**	The information needed during line reordering.

	@internalComponent	*/

	class TReorderContext

		{

	public:

		void SetNextCategory(TChar::TBdCategory aCat);

		void SetNextStrongCategory(TChar::TBdCategory aCat);

	public:

		/** Category at start of next line, or ON if at the end of the

		paragraph. */

		TCategory iNextCategory;

		/** Which of L, R or AL appears first in the remainder of the

		paragraph, or ON if none. */

		TCategory iNextStrongCategory;

		/** The run array for this line. */

		TRunInfo* iRunInfo;

		/** The length of iRunInfo. */

		TInt iRuns;

		/** Bitmap of categories currently present in iRunInfo. */

		TUint32 iCategories;

		/** Found by the algorithm to set iPreviousStrongCategory. */

		TCategory iLastStrongCategory;

		};

public:

	static TInt GenerateBdRunArray(const TText* aText, TInt aLength,

		TBidirectionalState::TRunInfo* aRun, TInt aMaxRuns);

private:

	const TStackItem& State() const { return iStack[iStackLevel]; }

	TCategory Push(TCategory aStartCategory);

	TCategory Pop();

public:

	TBidirectionalState(TChar::TBdCategory aPrevCat,

		TChar::TBdCategory aPrevStrongCat, TBool aParRightToLeft);

	void HandleBdControls(TReorderContext& aContext); 

	void ResolveWeakTypesW1W2W3(TReorderContext& aContext);

	void ResolveWeakTypesW4W5W6(TReorderContext& aContext); 

	void ResolveWeakTypesW7(TReorderContext& aContext); 

	void ResolveNeutralTypes(TReorderContext& aContext); 

	void ResolveImplicitLevels(TReorderContext& aContext); 

	void PrepareForNextLine(const TReorderContext& aContext);

	void ReorderRuns(TReorderContext& aContext);

	static TInt CatToNumber(TInt aCat);

	static TCategory CharToBdCat(TChar::TBdCategory aCat);

	static TCategory UintToBdCat(TUint aCat);

	static void DeneutralizeRuns(TRunInfo* aStart, TRunInfo* aEnd,

		TCategory aStartCategory, TCategory aEndCategory);

private:

	TCategory iPreviousCategory;			// category at end of last line, or EStartOfParagraph if at start of par

	TCategory iPreviousStrongCategory;		// L or R; derived from embedding level if at start of par

	TInt16 iStackLevel;						// current stack level

	TInt8 iPushesBeyond60;	// number of times Push called with iStackLevel == 60 and Left-To-Right category

	TInt8 iPushesBeyond61;	// number of times Push called with iStackLevel == 61

	TStackItem iStack[EMaxStackLevels];		// the stack of embedding levels

	};

#endif // BIDI_H_