// 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 "BidiCompact.h"

#include "BidiCopy.h"

#include <textbase.h>

static const TInt KZeroWidthJoiner = 0x200D;

// This gets round the compiler warning about converting

// EFRightToLeft to unsigned long.

inline TUint FRightToLeft() { return static_cast<TUint>(TRunInfoCompact::EFRightToLeft); }

/**

Constructs a run description without considering optimisations based

on the text itself.

@param aStart Index of the start of the run.

@param aLength Length of the run.

@param aReverse ETrue if the run is right-to-left.

@internalTechnology

*/

TRunInfoCompact::TRunInfoCompact(TInt aStart, TInt aLength,

	TBool aReverse)

	: iStart(aStart), iLengthAndType(aLength)

	{

	if (aReverse)

		iLengthAndType |= FRightToLeft();

	}

/**

Constructs a run description.

@param aStart Index of the start of the run.

@param aLength Length of the run.

@param aReverse ETrue if the run is right-to-left.

@param aText The text that this run refers to (starting at index 0, not

the start of the run). This is required only to determine if optimisations 

to the re-ordering are possible.

@internalTechnology

*/

TRunInfoCompact::TRunInfoCompact(TInt aStart, TInt aLength,

	TBool aReverse, const TText* aText)

	: iStart(aStart), iLengthAndType(aLength)

	{

	ASSERT(0 <= aLength);

	ASSERT(aLength < 0x10000000);

	ASSERT(0 <= aStart);

	if (!aReverse)

		return;

	iLengthAndType |= FRightToLeft();

	TUint32 flags = EFNoPairsNoCombiners | EFNoMirroredCharacters;

	aText += aStart;

	for (const TText* end = aText + aLength; aText < end && flags; ++aText)

		{

		TInt code = *aText;

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

			{

			flags &= ~EFNoPairsNoCombiners;

			if ((code & 0xFC00) == 0xDC00

				&& aText + 1 < end

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

				{

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

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

				++aText;

				}

			}

		TChar c = code;

		if (c.GetCombiningClass() != 0)

			flags &= ~EFNoPairsNoCombiners;

		if (BidiCopy::Mirror(code) != code)

			flags &= ~EFNoMirroredCharacters;

		}

	iLengthAndType |= flags;

	}

/**

Attempts to extend a run.

@param aToBeAdded The run to be merged.

@return ETrue if extension succeeded, EFalse if not.

@internalTechnology

*/

TBool TRunInfoCompact::AddRun(const TRunInfoCompact& aToBeAdded)

	{

	TInt length = Length();

	if (length == 0)

		{

		*this = aToBeAdded;

		return ETrue;

		}

	// Are both runs in the same direction?

	if ((iLengthAndType ^ aToBeAdded.iLengthAndType) & FRightToLeft())

		return EFalse;

	TBool rightToLeft = TypeFlags() & EFRightToLeft;

	TInt end = rightToLeft?

		Start() - Length() : Start() + Length();

	if (end != aToBeAdded.Start())

		return EFalse;

	length += aToBeAdded.Length();

	iLengthAndType = length | (TypeFlags() & aToBeAdded.TypeFlags());

	if (rightToLeft)

		iStart -= aToBeAdded.Length();

	return ETrue;

	}

/**

Reorders text described by this run according to aContext. Allow 6 extra

bytes for a truncation.

@param aDestination	Where to write this run of visually-ordered text to.

@param aContext The source of the text to be ordered.

@return	The first byte not written to: in other words, what aDestination

should be updated to.

@internalTechnology

*/

TText* TRunInfoCompact::Reorder(TText* aDestination,

	const TRunInfoCompact::TReorderingContext& aContext) const

	{

	TInt start = Start();

	if (aContext.iEnd < start)

		// does not overlap

		return aDestination;

	TInt end = Start() + Length();

	if (end <= aContext.iStart)

		// does not overlap

		return aDestination;

	TBool startJoins = EFalse;

	if (start <= aContext.iStart)

		{

		start = aContext.iStart;

		startJoins = aContext.iJoinsAtStart;

		}

	TBool truncated = EFalse;

	TBool endJoins = EFalse;

	if (aContext.iEnd <= end)

		{

		if (aContext.iEnd < end

			&& aContext.iTruncation != 0xFFFF)

			truncated = ETrue;

		end = aContext.iEnd;

		endJoins = aContext.iJoinsAtEnd;

		}

	TInt length = end - start;

	if (length == 0 && !truncated)

		return aDestination;

	ASSERT(0 <= length);

	const TText* source = aContext.iSource + start;

	if (TypeFlags() & FRightToLeft())

		{

		// Right-to-left

		if (truncated)

			aDestination = BidiCopy::OutputTChar(aDestination, aContext.iTruncation);

		if (endJoins)

			*(aDestination++) = KZeroWidthJoiner;

		if (TypeFlags() & EFNoPairsNoCombiners)

			{

			// Simple

			aDestination = TypeFlags() & EFNoMirroredCharacters?

				BidiCopy::CopyBackwards(aDestination, source, length)

				: BidiCopy::CopyBackwardsWithMirroring(aDestination, source, length);

			}

		else

			// Respect groups

			aDestination = BidiCopy::CopyGroupsBackwards(aDestination, source, length);

		if (startJoins)

			*aDestination++ = KZeroWidthJoiner;

		return aDestination;

		}

	// Left-to-right

	if (startJoins)

		*aDestination++ = KZeroWidthJoiner;

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

	aDestination += length;

	if (endJoins)

		*aDestination++ = KZeroWidthJoiner;

	if (truncated)

		aDestination = BidiCopy::OutputTChar(aDestination, aContext.iTruncation);

	return aDestination;

	}

/**

Converts an array of aArraySize TBidirectionalState::TRunInfos into a

compact form.

@param aBuffer Memory to output to, or null just to find out how large the output

array will need to be.

@param aText The text that aRunArray refers to.

@param aRunArray The array to be converted.

@param aArraySize The length of aRunArray.

@return The length of the output array.

@internalTechnology

*/

TInt TRunInfoCompact::Convert(TRunInfoCompact* aBuffer, const TDesC& aText,

	const TBidirectionalState::TRunInfo* aRunArray, TInt aArraySize)

	{

	const TText* text = aText.Ptr();

	TInt outputSize =  0;

	TRunInfoCompact currentRun;

	while (aArraySize)

		{

		TRunInfoCompact newRun(aRunArray->iStart, aRunArray->iLength,

			aRunArray->iDirection, text);

		--aArraySize;

		if (!currentRun.AddRun(newRun))

			{

			if (aBuffer)

				*aBuffer++ = currentRun;

			++outputSize;

			currentRun = newRun;

			}

		++aRunArray; //point to next run

		}

	if (0 < currentRun.Length())

		{

		if (aBuffer)

			*aBuffer++ = currentRun;

		++outputSize;

		}

	return outputSize;

	}

/**

Utility tells whether a character will form a join with the previous

base character.

@param aText The text.

@param aIndex The index into aText of the character to test.

@return ETrue if there is a join before the character.

*/

TBool TRunInfoCompact::JoinBefore(const TText* aText, TInt aIndex)

	{

	TInt charUnderTest = aText[aIndex];

	if (!CFont::CharactersJoin(charUnderTest, KZeroWidthJoiner))

		// Character does not join with anything, so we

		// will not do any more work.

		return EFalse;

	while (aIndex != 0)

		{

		--aIndex;

		TInt c = aText[aIndex];

		// If it is an Arabic point, we will skip it.

		if (0x64B <= c && c < 0x671

			&& !(0x656 <= c && c < 0x670))

			continue;

		return CFont::CharactersJoin(charUnderTest, c);

		}

	return EFalse;

	}