// Copyright (c) 2002-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 "BidiCopy.h"

#include <e32std.h>

#include "mglyphs.inl"

TInt BidiCopy::Mirror(TInt a)

/**

Find the mirror image of a character.

@internalComponent

*/

	{

	TInt current = MirrorStart(a);

	unsigned long v = mGlyphArray[current];

	TInt key = v >> 16;

	// 1st easy-out: no steps at all for any at this key

	if (key == 0)

		return a;

	// 2nd easy-out: no steps at all but we have found it

	if (key == a)

		return v & 0xFFFF;

	TInt step = MirrorStep(a);

	do	{

		current += step;

		current &= (KMirrorTableSize-1);

		key = mGlyphArray[current] >> 16;

		if (key == a)

			return mGlyphArray[current] & 0xFFFF;

		} while (key != 0);

	return a;

	}

void BidiCopy::ReverseCodes(TText* aText, TInt aLength)

/**

Reverse the contents of aText[0..aLength], so that aText[0] holds the

value previously found in aText[aLength - 1], aText[1] holds the value

previously held in aText[aLength - 2] and so on.

@internalComponent

*/

	{

	TText *text = aText;	// backup

	// reverse int16 by int16 (note: high surrogate + low surrogate will be reverse to low surrogate + high surrogate)

	TText* end = aText + aLength - 1;

	while (aText < end)

		{

		TText t = *aText;

		*aText = *end;

		*end = t;

		++aText;

		--end;

		}

	CorrectSurrogatePairs(text, aLength);

	}

void BidiCopy::DeleteUnreversedSurrogates(TText* aText, TInt aLength)

/**

Replaces all surrogates with 0xFFFF that are not paired up the wrong

way round.

@internalComponent

*/

	{

	if (aLength < 1)

		return;

	TText* end = aText + aLength;

	while (aText < end)

		{

		if ((aText[0] & 0xF800) == 0xD800)

			{

			if ((aText[0] & 0xFC00) == 0xD800

				&& aText + 1 != end

				&& (aText[1] & 0xFC00) == 0xDC00)

				++aText;

			else

				aText[0] = 0xFFFF;

			}

		++aText;

		}

	}

void BidiCopy::CorrectSurrogatePairs(TText* aText, TInt aLength)

/**

Corrects all reversed surrogate pairs. Assumes that no unpaired

surrogates are present.

@internalComponent

*/

	{

	TText* end = aText + aLength;

	while (aText < end)

		{

		if ((aText[0] & 0xF800) == 0xD800)

			{

			// Surrogate pair discovered.

			// Do we need to swap it?

			ASSERT(aText + 1 < end);

			ASSERT((aText[1] & 0xF800) == 0xD800);

			if ((aText[0] & 0xFC00) == 0xDC00)

				{

				ASSERT((aText[1] & 0xFC00) == 0xD800);

				TText t = aText[0];

				aText[0] = aText[1];

				aText[1] = t;

				}

			++aText;

			}

		++aText;

		}

	}

void BidiCopy::CorrectGroups(TText* aText, TInt aLength)

/**

Correct all reversed groups (non-combiner followed by combining

characters). Surrogate pairs may be reversed by this operation.

Assumes that no unpaired surrogates are present.

Leading and trailing 0xFFFFs are left alone.

@internalComponent

*/

	{

	TText *end = aText + aLength;

	// Ignore leading 0xFFFFs. This helps Tagma's

	// RTmTextCache::GetDisplayedText with its sentinels.

	while (aText < end && *aText == 0xFFFF)

		++aText;

	TText* groupStart = aText;

	while (aText < end)

		{

		TText* next = aText + 1;

		TInt c = aText[0];

		if ((c & 0xFC00) == 0xD800)

			{

			ASSERT(aText + 1 < end);

			ASSERT((aText[1] & 0xFC00) == 0xDC00);

			c = (c << 10) + (aText[1] & 0x3FF)

				+ (0x10000 - 0xD800*0x400);

			++next;

			}

		// ignore non-characters

		if ((c & 0xFFFE) != 0xFFFE)

			{

			// non-marks represent the end of groups that may need to

			// be reversed

			TChar ch = c;

			if ((ch.GetCategory() & 0xFFFFFFF0) != TChar::EMarkGroup)

				{

				if (aText != groupStart)

					ReverseCodes(groupStart, aText - groupStart + 1);

				groupStart = next;

				}

			}

		aText = next;

		}

	}

void BidiCopy::SubstituteMirrorImages(TText* aText, TInt aLength)

/**

Reverse all mirror image characters. Will not change characters

in the basic multilingual plane for surrogate pairs. Assumes

that no unpaired surrogates are present.

@internalComponent

*/

	{

	TText *end = aText + aLength;

	while (aText < end)

		{

		TText* next = aText + 1;

		TInt c = aText[0];

		if ((c & 0xFC00) == 0xD800)

			{

			ASSERT(aText + 1 < end);

			ASSERT((aText[1] & 0xFC00) == 0xDC00);

			c = (c << 10) + (aText[1] & 0x3FF)

				+ (0x10000 - 0xD800*0x400);

			++next;

			}

		TInt m = Mirror(c);

		if (m != c)

			{

			if (m <= 0xFFFF)

				{

				aText[0] = static_cast<TText>(m);

				if (0xFFFF < c)

					aText[1] = 0xFFFF;

				}

			else if (0xFFFF < c)

				{

				aText[0] = static_cast<TText>((c >> 10) + 0xD760);

				aText[1] = static_cast<TText>((c & 0x3FF) + 0xDC00);

				}

			}

		aText = next;

		}

	}

TText* BidiCopy::CopyMirror(TText* aDestination, const TText* aSource, TInt length)

/**

Copy some text, substituting mirrored characters.

@return aDestination + number of TText codes output.

@internalComponent

*/

	{

	for (; length; --length, ++aDestination, ++aSource)

		*aDestination = static_cast<TText>(Mirror(*aSource));

	return aDestination;

	}

TText* BidiCopy::OutputTChar(TText* aDestination, TInt aToOutput)

/**

Write out the input character as UTF16.

@return aDestination + number of TText codes output.

@internalComponent

*/

	{

	if (aToOutput > 0xFFFF)

		{

		TInt c = aToOutput;

		aDestination[0] = static_cast<TText>((c >> 10) + 0xD760);

		aDestination[1] = static_cast<TText>((c & 0x3FF) + 0xDC00);

		return aDestination + 2;

		}

	*aDestination = static_cast<TText>(aToOutput);

	return aDestination + 1;

	}

TText* BidiCopy::CopyBackwards(TText* aDestination,

	const TText* aSource, TInt aLength)

/**

Copy the text backwards without substituting mirrored characters,

checking for surrogate pairs or combining characters.

@return aDestination + number of TText codes output.

@internalComponent

*/

	{

	TText *end = aDestination + aLength;

	while (aDestination != end)

		{

		*--end = *aSource++;

		}

	return aDestination + aLength;

	}

TText* BidiCopy::CopyBackwardsWithMirroring(TText* aDestination,

	const TText* aSource, TInt aLength)

/**

Copy the text backwards to the output without checking for surrogate

pairs or combining characters, substituting mirrored characters.

@return aDestination + number of TText codes output.

@internalComponent

*/

	{

	TText *end = aDestination + aLength;

	while (aDestination != end)

		{

		*--end = static_cast<TText>(Mirror(*aSource++));

		}

	return aDestination + aLength;

	}

TText* BidiCopy::CopyGroupsBackwards(TText* aDestination,

	const TText* aSource, TInt aLength)

/**

Copy the text backwards, substituting mirrored characters and correctly

handling all surrogate pairs and combining characters.

@return aDestination + number of TText codes output.

@internalComponent

*/

	{

	TText* retval = CopyBackwards(aDestination, aSource, aLength);

	DeleteUnreversedSurrogates(aDestination, aLength);

	SubstituteMirrorImages(aDestination, aLength);

	CorrectGroups(aDestination, aLength);

	CorrectSurrogatePairs(aDestination, aLength);

	return retval;

	}

TBool BidiCopy::ImplicitDirectionalityIsRightToLeft(

	const TText* aText, TInt aLength, TBool* aFound)

/**

Find out if the implicit directionality of a piece of text is right to

left.

@param aText Text to be examined, or the first portion of text to be examined.

@param aLength Length of the text.

@param aFound If non-null, returns ETrue if the directionality could be

determined from aText. If not, and there is more text beyond, the function 

should be called with the next portion of text until aFound returns ETrue 

or there is no more text.

@return	ETrue if the directionality is right to left. If the directionality

cannot be determined solely from this text, EFalse is returned.	This is the 

implicit directionality of text that is composed entirely of neutrals.

@internalComponent

*/

	{

	if (aFound)

		*aFound = ETrue;

	const TText* end = aText + aLength;

	TInt lastUtf16 = 0;

	while (aText != end)

		{

		TInt code = *aText++;

		if ((code & 0xFFFFFC00) == 0xD800

			&& (lastUtf16 & 0xFFFFFC00) == 0xDC00)

			{

			code = (code << 10) + (lastUtf16 & 0x3FF)

				+ (0x10000 - 0xD800*0x400);

			}

		lastUtf16 = code;

		TChar c = code;

		switch(c.GetBdCategory())

			{

		case TChar::ELeftToRight:

			return EFalse;

		case TChar::ERightToLeft:

		case TChar::ERightToLeftArabic:

			return ETrue;

		default:

			break;

			}

		}

	if (aFound)

		*aFound = EFalse;

	return EFalse;

	}