// 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:

//

#ifndef __TBIDI_H__

#define __TBIDI_H__

#include "TGraphicsHarness.h"

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;

	}

inline TText16 GetHighSurrogate(TUint aChar)

/**

Retrieve the high surrogate of a supplementary character.

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

@return High surrogate of aChar, if aChar is a supplementary character; 

        aChar itself, if aChar is not a supplementary character.

*/

	{

	return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10));

	}

inline TText16 GetLowSurrogate(TUint aChar)

/**

Retrieve the low surrogate of a supplementary character.

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

@return Low surrogate of aChar, if aChar is a supplementary character; 

        zero, if aChar is not a supplementary character.

*/

	{

	return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF));

	}

void AppendCharacter(HBufC *aDes, TUint aChar);

void AppendCharacter(TBuf<24> *aDes, TUint aChar);

// Class to implement a wrapping iterator meant for extracting 16 bit characters

// from a block of text

// This class can handle surrogate pairs correctly.

class TextIterator

	{

public:

	TextIterator(const TText16* aData, const TInt aLength) : 

	  iData(aData), iLength(aLength), iIndex(0), iWrapped(EFalse), iCombineSurrogatePairs(ETrue)

		{

		}	

	TextIterator(const TText16* aData, const TInt aLength, const TInt aIndex) : 

		iData(aData), iLength(aLength), iIndex(aIndex), iWrapped(EFalse), iCombineSurrogatePairs(ETrue)

		{

		}

	TextIterator(const TText16* aData, const TInt aLength, const TInt aIndex, TBool aCombineSurrogatePairs) : 

		iData(aData), iLength(aLength), iIndex(aIndex), iWrapped(EFalse), iCombineSurrogatePairs(aCombineSurrogatePairs)

		{

		}

	// Next character from data - wrap pointer to keep within data.

	// Get current char, then move the internal pointer forward to next char.

	TUint NextChar()

		{

		TUint ch = Char();

		if (iCombineSurrogatePairs && IsSupplementary(ch))

			iIndex += 2;

		else

			iIndex += 1;

		// wrap

		if (iIndex >= iLength)

			{

			iIndex = 0;

			iWrapped = ETrue;

			}

		return ch;

		}

	// Move the internal pointer backward, then return the char pointed by internal char.

	// Panic if iIndex already = 0.

	TUint PreviousChar()

		{

		ASSERT(iIndex > 0);

		iIndex--;

		if (iCombineSurrogatePairs && IsLowSurrogate(iData[iIndex]))

			{

			ASSERT(iIndex > 0);

			iIndex--;

			ASSERT(IsHighSurrogate(iData[iIndex]));

			}

		else if (iCombineSurrogatePairs && IsHighSurrogate(iData[iIndex]))

			{

			ASSERT(EFalse);

			}

		else

			{

			// do nothing

			}

		return Char();

		}

	//Reset the iterator to the original values

	void Reset()

		{

		iIndex = 0;

		iWrapped = EFalse;

		}

	void SetIndex(const TInt aIndex)

		{

		iIndex = aIndex;

		iWrapped = EFalse;

		}

	//Has the iterator wrapped back to the start of the buffer at least once?

	TBool Wrapped() const

		{

		return iWrapped;

		}

	//Where is the current buffer index?

	TInt Index() const

		{

		return iIndex;

		}

	//Return pointer to data

	const TText16* Ptr() const

		{

		return iData;

		}

	//Get length of data

	TInt Length() const

		{

		return iLength;

		}

	//Get character at current index

	TUint Char() const

		{

		TUint ch = 0xFFFF;

		TText16 i16 = iData[iIndex];

		if (iCombineSurrogatePairs && IsHighSurrogate(i16))

			{

			ASSERT(iIndex+1 < iLength);

			TText16 low = iData[iIndex+1];

			ch = JoinSurrogate(i16, low);

			}

		else if (iCombineSurrogatePairs && IsLowSurrogate(i16))

			{

			ASSERT(EFalse);

			}

		else

			{

			ch = i16;

			}

		return ch;

		}

	// Fill aBuffer with a char, fill at aIndex, guarded by aMaxIndex (excluded).

	// After return, aIndex points to the next position, if aUpdate_aIndex=ETrue.

	// aUpdate_aIndex: do you want to update the parameter aIndex?

	// aUpdate_iIndex: do you want to update the member variable iIndex?

	// aChar: [out] current char

	TBool NextCharInto(TDes &aBuffer, TInt &aIndex, TInt aMaxIndex=-1, TBool aUpdate_aIndex=ETrue, TBool aUpdate_iIndex=ETrue, TUint *aChar=NULL)

		{

		if (aMaxIndex < 0)

			aMaxIndex = aBuffer.Length();

		if (aIndex >= aMaxIndex)

			return EFalse;

		TUint ch = Char();

		if (iCombineSurrogatePairs && IsSupplementary(ch))

			{

			if (aIndex+1 >= aMaxIndex)

				return EFalse;

			aBuffer[aIndex] = GetHighSurrogate(ch);

			aBuffer[aIndex+1] = GetLowSurrogate(ch);

			if (aUpdate_aIndex)

				aIndex += 2;

			}

		else

			{

			aBuffer[aIndex] = (TText16)ch;

			if (aUpdate_aIndex)

				aIndex++;

			}

		if (aChar)

			*aChar = ch;

		if (aUpdate_iIndex)

			{

			if (iCombineSurrogatePairs && IsSupplementary(ch))

				iIndex += 2;

			else

				iIndex += 1;

			if (iIndex >= iLength)

				{

				iIndex = 0;

				iWrapped = ETrue;

				}

			}

		return ETrue;

		}

	// Fill aBuffer from aIndex to aMaxIndex (excluded).

	// aMaxIndex=-1 means fill to index=aBuffer.Length.

	// After return, aIndex points to the next position, if aUpdate_aIndex=ETrue.

	TBool FillInto(TDes &aBuffer, TInt &aIndex, TInt aMaxIndex=-1)

		{

		if (aMaxIndex == -1)

			aMaxIndex = aBuffer.Length();

		while (aIndex < aMaxIndex)

			{

			TBool b = NextCharInto(aBuffer, aIndex, aMaxIndex);

			if (!b)

				{

				return ETrue;

				}

			}

		return ETrue;

		}

private:

	const TText16* iData;

	TInt  iLength;

	TInt  iIndex;

	TBool iWrapped;

	TBool iCombineSurrogatePairs;	// ETrue = combine surrogates; EFalse = take single surrogate as character

	};

class CTBiDiStep : public CTGraphicsStep

	{

public:

	CTBiDiStep();

protected:	

	//from CTGraphicsStep

	virtual CTGraphicsBase* CreateTestL();

	};

_LIT(KTBiDiStep,"TBiDi");

#endif