// Copyright (c) 2000-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:

// Bidirectional text reordering; based on the Unicode Bidirectional Reordering Algorithm.

// 

//

#include <bidi.h>

#include "BidiCopy.h"

#include <s32std.h>

const TInt KBidirectionalStateOverrideStreamValueNone = 0;

const TInt KBidirectionalStateOverrideStreamValueLeftToRight = 1;

const TInt KBidirectionalStateOverrideStreamValueRightToLeft = 2;

inline TBool IsSupplementary(TUint aChar)

/**

@param aChar The 32-bit code point value of a Unicode character.

@return True, if aChar is supplementary character; false, otherwise.

*/

	{

	return (aChar > 0xFFFF);

	}

inline TBool IsHighSurrogate(TText16 aInt16)

/**

@return True, if aText16 is high surrogate; false, otherwise.

*/

	{

	return (aInt16 & 0xFC00) == 0xD800;

	}

inline TBool IsLowSurrogate(TText16 aInt16)

/**

@return True, if aText16 is low surrogate; false, otherwise.

*/

	{

	return (aInt16 & 0xFC00) == 0xDC00;

	}

inline TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate)

/**

Combine a high surrogate and a low surrogate into a supplementary character.

@return The 32-bit code point value of the generated Unicode supplementary

        character.

*/

	{

	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;

	}

TBool TextDefaultsToRightToLeft(const TDesC& aText, TBool* aFound);

TBidirectionalState::TCategory TBidirectionalState::CharToBdCat(TChar::TBdCategory aCat)

	{

	return static_cast<TBidirectionalState::TCategory>(

		1 << static_cast<TInt>(aCat));

	}

TBidirectionalState::TCategory TBidirectionalState::UintToBdCat(TUint aCat)

	{

	return static_cast<TBidirectionalState::TCategory>(1 << aCat);

	}

void TBidirectionalState::TReorderContext::SetNextCategory(

	TChar::TBdCategory aCat)

	{

	iNextCategory = CharToBdCat(aCat);

	}

void TBidirectionalState::TReorderContext::SetNextStrongCategory(

	TChar::TBdCategory aCat)

	{

	iNextStrongCategory = CharToBdCat(aCat);

	}

EXPORT_C void TBidirectionalState::ReverseGroups(TText* aStart,TInt aLength)

/** A utility to reverse text apart from combining characters, which remains after 

their base characters. This is what is needed when drawing right-to-left text.

@param aStart Start position of text to be reversed.

@param aLength Length of text to be reversed. */

	{

	BidiCopy::ReverseCodes(aStart, aLength);

	BidiCopy::DeleteUnreversedSurrogates(aStart, aLength);

	BidiCopy::SubstituteMirrorImages(aStart, aLength);

	BidiCopy::CorrectGroups(aStart, aLength);

	BidiCopy::CorrectSurrogatePairs(aStart, aLength);

	}

// A local helper function. Get the next character from a buffer. This

// function won't check buffer length.

//

// @param aText The text buffer to read character from.

// @param aCharacterIndex Count of characters to skip in aText.

// @return The character.

TUint GetOneCharacter(const TText16 *aText, TInt aCharacterIndex)

	{

	const TText16 *p = aText;

	TUint c = 0xFFFF;

	while (aCharacterIndex >= 0)

		{

		c = *p++;

		ASSERT(!IsLowSurrogate(c));

		if (IsHighSurrogate(c))

			{

			ASSERT(IsLowSurrogate(*p));

			c = JoinSurrogate(c, *p++);

			}

		--aCharacterIndex;

		}

	return c;

	}

TInt TBidirectionalState::GenerateBdRunArray(const TText* aText, TInt aLength,

	TBidirectionalState::TRunInfo* aRun, TInt aMaxRuns)

/** Analyse the input text for runs of characters that share the same

bidirectional class. Categories TChar::EEuropeanNumberSeparator and

TChar::ECommonNumberSeparator are kept as singletons due to a limitation in

the reordering logic.

@param aText The text to be analysed.

@param aLength The length of the text to be analysed.

@param aRun	Output buffer for the runs after analysis. May be null if there 

is to be no output.

@param aMaxRuns The size of the aRun array. No more than this number of runs 

will be	output.

@return The number of runs that are required for the full results of the

analysis.

@internalTechnology */	

    {

	if (aLength == 0)

		{

		if (aRun && 0 < aMaxRuns)

			{

			aRun[0].iCategory = TChar::EOtherNeutral;

			aRun[0].iStart = 0;

			aRun[0].iLength = 0;

			}

		return 1;

		}

	int runs = 0;

	int run_start = 0;

	int run_end = 1;

	const TText* p = aText;

	const TText* q = p + aLength;

	// get the character pointed by 'p', then move 'p' to next character, and adjust 'run_end' if need

	TChar pc = ::GetOneCharacter(p, 0);

	TChar::TBdCategory cur_cat = pc.GetBdCategory();

	++p;

	if (IsSupplementary(pc))

		{

		++p;

		run_end = 2;	// run_end points to "end" of current character

		}

	while (p < q)

		{

		// get the character pointed by 'p'

		pc = ::GetOneCharacter(p, 0);

		TChar::TBdCategory new_cat = pc.GetBdCategory();

		if (new_cat != cur_cat)

			{

			if (new_cat == TChar::ENonSpacingMark &&

				cur_cat != TChar::ELeftToRightEmbedding &&

				cur_cat != TChar::ELeftToRightOverride &&

				cur_cat != TChar::ERightToLeftEmbedding &&

				cur_cat != TChar::ERightToLeftOverride &&

				cur_cat != TChar::EPopDirectionalFormat)

				new_cat = cur_cat;

			else if (p < q - 1 &&

					 (new_cat == TChar::EWhitespace ||

					  new_cat == TChar::EEuropeanNumberSeparator ||

					  new_cat == TChar::ECommonNumberSeparator))

				{

				TChar nextChar = ::GetOneCharacter(p, 1);

				TChar::TBdCategory next_cat = nextChar.GetBdCategory();

				if (new_cat == TChar::EWhitespace)

					{

					if ((cur_cat == TChar::ELeftToRight ||

						 cur_cat == TChar::ERightToLeft ||

						 cur_cat == TChar::ERightToLeftArabic) && cur_cat == next_cat)

						new_cat = cur_cat;

					}

				else if (cur_cat == TChar::EEuropeanNumber && next_cat == TChar::EEuropeanNumber)

					new_cat = TChar::EEuropeanNumber;

				}

			}

		if (new_cat != cur_cat ||

			cur_cat == TChar::EEuropeanNumberSeparator ||

			cur_cat == TChar::ECommonNumberSeparator)

			{

			if (aRun && runs < aMaxRuns)

				{

				aRun[runs].iCategory = cur_cat;

				aRun[runs].iStart = run_start;

				aRun[runs].iLength = run_end - run_start;

				}

			runs++;

			run_start = run_end;

			}

		p++;

		run_end++;

		// adjust 'p' and 'run_end'

		if (IsSupplementary(pc))

			{

			p++;

			run_end++;

			}

		cur_cat = new_cat;

		}

	if (aRun && runs < aMaxRuns)

		{

		aRun[runs].iCategory = cur_cat;

		aRun[runs].iStart = run_start;

		aRun[runs].iLength = run_end - run_start;

		}

	return runs + 1;

	}

EXPORT_C TInt TBidirectionalState::ReorderText(const TText* aText,TInt aLength,TBool aParRightToLeft,

											   TText*& aNewText)

/** Reorders text according to the Unicode Bidirectional Reordering algorithm.

Reorders the input text from logical order (which may be bidirectional) to 

display order (strictly left to right).

@param aText The input text in logical order.

@param aLength The length of the input text.

@param aParRightToLeft ETrue if the default directionality of the text to be 

re-ordered is right-to-left.

@param aNewText Returns the re-ordered text. If the text did not need re-ordering, 

or if there was an error, aText will be returned. Otherwise, ownership of 

a newly allocated buffer will be returned to the caller. This buffer must 

be deleted with delete[] (or CleanupArrayDeletePushL()) and not delete (or 

CleanupStack::PushL()).

@return A system-wide error value if there has been an error; KErrNone if there 

has not. */

	{

	aNewText = const_cast<TText*>(aText);

	if (aLength < 2)

		return KErrNone;

	int error = KErrNone;

	TBidirectionalState::TRunInfo run_info;

	run_info.iDirection = 0;

	run_info.iIndex = 0;

	run_info.iStart = 0;

	run_info.iLength = aLength;

	TBidirectionalState::TRunInfo* run_info_array = &run_info;

	TBidirectionalState::TRunInfo* allocated_run_info_array = 0;

	int runs = GenerateBdRunArray(aText, aLength, run_info_array, 1);

	if (runs > 1)

		{

		allocated_run_info_array = new TBidirectionalState::TRunInfo[runs];

		if (allocated_run_info_array)

			{

			run_info_array = allocated_run_info_array;

			GenerateBdRunArray(aText, aLength, run_info_array, runs);

			}

		else

			{

			// the run cannot be allocated: stick with our single l-to-r run

			error = KErrNoMemory;

			runs = 1;

			}

		}

	if (error == KErrNone)

		{

		TBidirectionalState state;

		state.ReorderLine(run_info_array, runs, ETrue, ETrue, aParRightToLeft,

			TChar::EOtherNeutral, TChar::EOtherNeutral);

		}

	// If there was only one run and it's left-to-right, we've finished.

	if (!allocated_run_info_array && run_info.iDirection == 0)

		return error;

	// Reorder the text into a new buffer.

	TText* buffer = new TText[aLength];

	if (!buffer)

		{

		delete [] allocated_run_info_array;

		return KErrNoMemory;

		}

	const TBidirectionalState::TRunInfo* r = run_info_array;

	TText* dest = buffer;

	for (int i = 0; i < runs; i++, r++)

		{

		const TText* source = &aText[r->iStart];

		int length = r->iLength;

		Mem::Copy(dest,source,length * sizeof(TText));

		if (r->iDirection)

			ReverseGroups(dest,length);

		dest += length;

		}

	delete [] allocated_run_info_array;

	aNewText = buffer;

	return KErrNone;

	}

EXPORT_C TBidirectionalState::TBidirectionalState()

/** Standard constructor. */

	{

	Reset();

	}

/** Reorders a line of text and updates the bidirectional state for the next line.

@param aRunInfo An array of objects representing runs of characters with the 

same bidirectional category. Any number of characters can be combined into 

a run if they have the same category, except for the categories TChar::EEuropeanNumberSeparator 

and TChar::ECommonNumberSeparator, which should be put into single-character 

runs because the reordering logic depends on this.

@param aRuns Number of 'run info' objects.

@param aParStart Tells the function whether the line is the first line of a 

paragraph.

@param aParEnd Tells the function whether the line is the last line of a paragraph.

@param aParRightToLeft ETrue if the default directionality of the text to be 

re-ordered is right-to-left.

@param aNextCategory The category of the character immediately after the end 

of the line. This is ignored if aParEnd is ETrue.

@param aNextStrongCategory The category of the first strong character (one 

of the categories ELeftToRight, ELeftToRightEmbedding, ELeftToRightOverride, 

ERightToLeft, ERightToLeftArabic, ERightToLeftEmbedding or ERightToLeftOverride) 

after the end of the line. This is ignored if aParEnd is ETrue.

@param aVisualEndIsAmbiguous EFalse if the logical end of this line is at the

visual end and the logical beginning of the next line is at the visual beginning.

*/

EXPORT_C void TBidirectionalState::ReorderLine(TRunInfo* aRunInfo, TInt aRuns,

	TBool aParStart, TBool aParEnd, TBool aParRightToLeft,

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

	TBool& aVisualEndIsAmbiguous)

	{

	ReorderLine(aRunInfo, aRuns, aParStart, aParEnd, aParRightToLeft,

		aNextCategory, aNextStrongCategory);

	if (iStackLevel  != 0)

		{

		aVisualEndIsAmbiguous = ETrue;

		return;

		}

	TCategory nextCat = CharToBdCat(aNextCategory);

	TCategory nextStrong = CharToBdCat(aNextStrongCategory);

	const TUint KAllStrongLeftToRight =

		ELeftToRight | ELeftToRightEmbedding | ELeftToRightOverride;

	const TUint KAllStrongRightToLeft =

		ERightToLeft | ERightToLeftArabic | ERightToLeftEmbedding | ERightToLeftOverride;

	if (aParRightToLeft)

		{

		// Ambiguous if any of the surrounding categories are strongly left-to-right

		aVisualEndIsAmbiguous =

			(iPreviousStrongCategory | iPreviousCategory | nextCat | nextStrong)

			& KAllStrongLeftToRight;

		}

	else

		{

		// Ambiguous if any of the surrounding categories are strongly right-to-left

		aVisualEndIsAmbiguous =

			(iPreviousStrongCategory | iPreviousCategory | nextCat | nextStrong)

			& KAllStrongRightToLeft;

		}

	}

/** Reorders a line of text and updates the bidirectional state for the next line.

@param aRunInfo An array of objects representing runs of characters with the 

same bidirectional category. Any number of characters can be combined into 

a run if they have the same category, except for the categories TChar::EEuropeanNumberSeparator 

and TChar::ECommonNumberSeparator, which should be put into single-character 

runs because the reordering logic depends on this.

@param aRuns Number of 'run info' objects.

@param aParStart Tells the function whether the line is the first line of a 

paragraph.

@param aParEnd Tells the function whether the line is the last line of a paragraph.

@param aParRightToLeft ETrue if the default directionality of the text to be 

re-ordered is right-to-left.

@param aNextCategory The category of the character immediately after the end 

of the line. This is ignored if aParEnd is ETrue.

@param aNextStrongCategory The category of the first strong character (one 

of the categories ELeftToRight, ELeftToRightEmbedding, ELeftToRightOverride, 

ERightToLeft, ERightToLeftArabic, ERightToLeftEmbedding or ERightToLeftOverride) 

after the end of the line. This is ignored if aParEnd is ETrue. */

EXPORT_C void TBidirectionalState::ReorderLine(TRunInfo* aRunInfo, TInt aRuns,

	TBool aParStart, TBool aParEnd, TBool aParRightToLeft,

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

	{

	// Reset if this is a new paragraph.

	if (aParStart)

		{

		Reset();

		iPreviousCategory = EOtherNeutral;

		if (aParRightToLeft)

			{

			iStack[0].iEmbeddingLevel = 1;

			iPreviousStrongCategory = ERightToLeft;

			}

		}

	// Initialise the context object.

	TReorderContext context;

	context.iRunInfo = aRunInfo;

	context.iRuns = aRuns;

	context.iLastStrongCategory = iPreviousStrongCategory;

	if (aParEnd)

		context.iNextCategory = context.iNextStrongCategory = EOtherNeutral;

	else

		{

		context.iNextCategory = CharToBdCat(aNextCategory);

		context.iNextStrongCategory = CharToBdCat(aNextStrongCategory);

		}

	// Initialise output data and find out what categories are present so that unnecessary steps can be skipped.

	context.iCategories = iPreviousCategory | context.iNextCategory | context.iNextStrongCategory;

	for (TInt i = 0; i != aRuns; ++i)

		{

		aRunInfo[i].iEmbeddingLevel = iStack[0].iEmbeddingLevel;

		aRunInfo[i].iDirection = 0;

		aRunInfo[i].iIndex = i;

		aRunInfo[i].iCategory = UintToBdCat(aRunInfo[i].iCategory);

		context.iCategories |= aRunInfo[i].iCategory;

		}

	// Do nothing if no right-to-left material is present.

	if (aRuns == 0 ||

		(iStackLevel == 0 && iStack[0].iEmbeddingLevel == 0 &&

		 !(context.iCategories & (ERightToLeftGroup | EBdControlsGroup))))

		return;

	// Perform the bidirectional algorithm.

	if ((context.iCategories & EBdControlsGroup) ||

		State().iOverrideState != ENoOverrideState)

		HandleBdControls(context);

	ResolveWeakTypesW1W2W3(context);

	ResolveWeakTypesW4W5W6(context);

	ResolveWeakTypesW7(context);

	if (context.iCategories & EOtherNeutral)

		ResolveNeutralTypes(context);

	ResolveImplicitLevels(context);

	PrepareForNextLine(context);

	ReorderRuns(context);

	}

void TBidirectionalState::PrepareForNextLine(const TReorderContext& aContext)

/**

Fold context information back into TBidirectionalState.

@internalComponent

*/	

   {

	if (aContext.iRuns != 0)

		{

		iPreviousCategory = static_cast<TCategory>(

			aContext.iRunInfo[aContext.iRuns - 1].iCategory);

		iPreviousStrongCategory = aContext.iLastStrongCategory;

		}

	}

void TBidirectionalState::HandleBdControls(TReorderContext& aContext)

/**

Handle LRO, RLO, LRE, RLE and PDF. After this phase, these categories will no

longer be found.

This corresponds to Unicode(3.2) Bidirectional Algorithm phases X1-X7.

Phase X8 is not required as the run is assumed to be all in one paragraph.

Phases X9-X10 are implicit in other functions.

@internalComponent

*/	

   {

	aContext.iCategories = iPreviousCategory | aContext.iNextCategory;

	for (TInt i = 0; i != aContext.iRuns; ++i)

		{

		TRunInfo* r = aContext.iRunInfo + i;

		TCategory nextCatInLine = i < aContext.iRuns - 1?

			(TCategory)(r[1].iCategory) : ENoCategory;

		TBool was_pdf = FALSE;

		if (r->iCategory & EBdControlsGroup)

			{

			if (r->iCategory == EPopDirectionalFormat)

				{

				if (iStackLevel > 0)

					{

					was_pdf = TRUE;

					r->iEmbeddingLevel = State().iEmbeddingLevel;

					if (nextCatInLine == State().iStartCategory)

						// Ignore POP-PUSH pair with nothing between.

						// This is surely wrong? Perhaps it is a hack to

						// help other parts of the algorithm. Must investigate.

						// TPB.

						r->iCategory = r[1].iCategory = EBoundaryNeutral;

					else

						{

						r->iCategory = Pop();

						}

					}

				else

					r->iCategory = EBoundaryNeutral;

				}

			else

				{

				// Category is LRE, RLE, LRO or RLO.