// 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 <e32svr.h>

#include "BidiTextImp.h"

#include "BidiCopy.h"

#include "BidiCompact.h"

#include <bidi.h>

#include <e32base.h>

//#include <textbase.h>

#include <gdi.h>

#include <linebreak.h>

_LIT(KBidiPanicCategory,"Bidi");

static const TInt KLineSeparator = 0x2028;

static const TInt KParagraphSeparator = 0x2029;

static const TInt KCodeCR = 0x000D;

static const TInt KCodeLF = 0x000A;

static const TInt KCodeEllipsis = 0x2026;

void DeleteTRunInfo(void* aRunInfo)

	{

	delete[] reinterpret_cast<TBidirectionalState::TRunInfo*>(aRunInfo);

	}

void BidiPanic(TInt aError)

	{

	User::Panic(KBidiPanicCategory, aError);

	}

// One page-full of TRunInfos

const TInt KMaxRunInfoArraySize = 4*1024 / sizeof(TBidirectionalState::TRunInfo);

const TInt KBidiTlsHandle = 0x101F633D;

/*

* Ref-counted TLS for the shared run info array used by the SetText() method.

*/

NONSHARABLE_CLASS(CBidiTextTls) : public CObject

	{

public:	

	static CBidiTextTls* NewL();

	static CBidiTextTls* GetTls();

	~CBidiTextTls();

	inline TUint MaxArraySize();

	inline TBidirectionalState::TRunInfo* RunArray();

private:

	CBidiTextTls();

	void ConstructL(TUint aMaxArraySize);

private:

	TBidirectionalState::TRunInfo* iRunInfoArray;

	TUint iMaxArraySize;	

	};

CBidiTextTls::CBidiTextTls()

:	iRunInfoArray(NULL),

 	iMaxArraySize(0)

	{

	}

CBidiTextTls::~CBidiTextTls()

	{

	UserSvr::DllFreeTls(KBidiTlsHandle);

	if (iRunInfoArray)

		{

		delete [] iRunInfoArray;	

		}

	}

TUint CBidiTextTls::MaxArraySize()

	{

	return iMaxArraySize;

	}

TBidirectionalState::TRunInfo* CBidiTextTls::RunArray()

	{

	return iRunInfoArray;

	}

/**

 * Helper function provided to simplify reading the TLS data and improve the

 * readability of the code 

 */

CBidiTextTls* CBidiTextTls::GetTls()

	{

	return reinterpret_cast<CBidiTextTls*>(UserSvr::DllTls(KBidiTlsHandle));

	}

CBidiTextTls* CBidiTextTls::NewL()

	{

	CBidiTextTls* self = new (ELeave) CBidiTextTls;

	CleanupClosePushL(*self);

	self->ConstructL(KMaxRunInfoArraySize);

	CleanupStack::Pop(self);

	return self;

	}

void CBidiTextTls::ConstructL(TUint aMaxArraySize)

	{

	iMaxArraySize = aMaxArraySize;

	iRunInfoArray = new (ELeave) TBidirectionalState::TRunInfo[aMaxArraySize];

	User::LeaveIfError(UserSvr::DllSetTls(KBidiTlsHandle, this));

	}

EXPORT_C RRunInfoArray::RRunInfoArray() 

:	iTls(NULL)

	{

	}

/** 

Creates the run array if necessary and increases the reference count on it.

RRunInfoArray::OpenL() must be called prior to calling TBidiText::SetText().

 */

EXPORT_C void RRunInfoArray::OpenL()

	{

	if(!iTls)

		{

		iTls = CBidiTextTls::GetTls();

		if(iTls)

			{

			iTls->Open();	// Increase ref count	

			}

		else	

			{

			iTls = CBidiTextTls::NewL();

			}

		}	

	}

/**

Decreases the reference count on the run array. The run array will be deleted

if the reference count reaches zero. The client application must ensure that

there is a matching call to Close() for every call to OpenL() or memory will

be leaked.

 */

EXPORT_C void RRunInfoArray::Close()

	{

	if(iTls)

		{

		iTls->Close();	

		iTls = NULL;

		}

	}

/**

@return Pointer to the run array buffer

@internalComponent

 */

TBidirectionalState::TRunInfo* RRunInfoArray::RunArray() const

	{

	return iTls ? iTls->RunArray() : NULL;

	}

/**

@return Number of bytes needed to hold the TBidiTextImp member variables, plus the 

		text data allocated off the end of the TBidiTextImp object.

@internalComponent

*/

TInt TBidiTextImp::RequiredBytes(TInt aLength, TInt aMaxLines, TInt aBdRunArraySize)		

	{

	// size of TBidiTextImp class

	TInt bytes = TBidiTextImp::AlignedSizeOf();

	// size of text for logical and visual orderings.

	// This includes aMaxLines - 1 line breaks with surrounding

	// zero-width joiners, and a truncation character (possibly

	// a surrogate pair) plus a zero-width joiner.

	bytes += sizeof(TText) * (aLength * 2 + aMaxLines * 3);

	// size of line length array

	bytes += sizeof(TInt16*) * aMaxLines;

	// alignment

	bytes = (bytes + 3) & 0xFFFFFFFC;

	// array of TRunInfoCompact

	bytes += sizeof(TRunInfoCompact) * aBdRunArraySize;

	return bytes;

	}

/**

@return A TBidiTextImp object of sufficient size to hold the amount of text data specified

		by the the arguments.

@param aLength The number of characters in the text.

@param aMaxLines The maximum number of lines 

@param aBdRunArraySize The size of the bidi run array. 

@internalComponent

*/

TBidiTextImp* TBidiTextImp::NewL(TInt aLength, TInt aMaxLines, TInt aBdRunArraySize)

	{

	const TInt bytes = RequiredBytes(aLength, aMaxLines, aBdRunArraySize);

	TInt8* mem = static_cast<TInt8*>(User::AllocL(bytes));

	TBidiTextImp* me = reinterpret_cast<TBidiTextImp*>(mem);

	me->iTextLengthAndFlags = aLength;

	me->iVisualOrderedTextLength = -1;

	me->iWrappingWidth = 0xFFFF;

	me->iBidiRunArrayLength = aBdRunArraySize;

	me->iLines = static_cast<TUint8>(aMaxLines);

	me->iTruncationCharPlane = 0;

	me->iTruncationChar16 = KCodeEllipsis;

	me->SetAllocatedTextDataBytes(bytes - TBidiTextImp::AlignedSizeOf() - (sizeof(TRunInfoCompact) * aBdRunArraySize));

	return me;

	}

/**

@return Position of logically-ordered text portion of the heap cell.

@internalComponent

*/

TText* TBidiTextImp::LogicalText()

	{

	return reinterpret_cast<TText*>(

		reinterpret_cast<TInt8*>(this)

		+ TBidiTextImp::AlignedSizeOf());

	}

/**

@return Position of visually-ordered text portion of the heap cell.

@internalComponent

*/

TText* TBidiTextImp::VisualText()

	{

	TInt bytes = TBidiTextImp::AlignedSizeOf();

	bytes += sizeof(TText) * TextLength();

	return reinterpret_cast<TText*>(

		reinterpret_cast<TInt8*>(this) + bytes);

	}

/**

Returns a pointer to the array containing the width in pixels of each and every line.

@return Position of the array of line widths portion of the heap cell.

@internalComponent

*/

TInt16* TBidiTextImp::LineWidthArray()

	{

	TInt bytes = TBidiTextImp::AlignedSizeOf();

	bytes += sizeof(TText) * (TextLength() * 2 + iLines + 2);

	return reinterpret_cast<TInt16*>(

		reinterpret_cast<TInt8*>(this) + bytes);

	}

/**

@return Position of the array of runs portion of the heap cell.

@internalComponent

*/

TRunInfoCompact* TBidiTextImp::BidiRunArray()

	{

	TInt bytes = TBidiTextImp::AlignedSizeOf();

	bytes += sizeof(TText) * (TextLength() * 2 + iLines + 2);

	bytes += sizeof(TInt16*) * iLines;

	bytes = (bytes + 3) & 0xFFFFFFFC;

	return reinterpret_cast<TRunInfoCompact*>(

		reinterpret_cast<TInt8*>(this) + bytes);

	}

/** 

Report if the current character is an explicit line break. Both

aText[0] and aText[1] must be part of the string.

@return Size of line break.

@internalComponent 

*/

TInt SizeLineBreak(const TText* aText, const TText* aTextEnd)

	{

	if (aText == aTextEnd )

		return 0;

	if (*aText == KLineSeparator || *aText == KParagraphSeparator

		|| *aText == KCodeLF)

		return 1;

	if (aText[0] == KCodeCR)

		{

		// first check for space before checking for LF

		if (aText+1 < aTextEnd )

			{

			return aText[1] == KCodeLF? 2 : 1;

			}

		else

			return 1;

		}

	return 0;

	}

/** 

Find the next line break character.

@internalComponent 

*/

const TText* FindEndOfThisLine(const TText* aStart, const TText* aEnd)

	{

	while (aStart != aEnd && *aStart != KLineSeparator

		&& *aStart != KParagraphSeparator && *aStart != KCodeLF

		&& *aStart != KCodeCR)

		++aStart;

	return aStart;

	}

/**

Count number of lines in text.

@internalComponent

*/

TInt NumberOfLines(const TText* aStart, const TText* aEnd)

	{

	TInt num = 0;

	while (aStart != aEnd)

		{

		aStart = FindEndOfThisLine(aStart, aEnd);

		aStart += SizeLineBreak(aStart, aEnd);

		++num;

		}

	return num;

	}

/** Returns the directionality of a given language.

@param aLanguage Language.

@return The directionality of the given language. */

EXPORT_C TBidiText::TDirectionality TBidiText::ScriptDirectionality(

	TLanguage aLanguage)

	{

	const TUint32 DirectionalityBitmap[] =

		{

		0,

		// Arabic, Farsi, Hebrew

		0x02040020,

		// Urdu

		0x40000000

		};

	TUint index = aLanguage;

	if (index < sizeof(DirectionalityBitmap) * 8)

		{

		index >>= 5;

		TInt bit = aLanguage & 31;

		return (DirectionalityBitmap[index] >> bit) & 1?

			ERightToLeft : ELeftToRight;

		}

	return ELeftToRight;

	}

/** Reports the implicit directionality of a piece of text.

@param aText The text to be examined. 

@param aFound If non-null, returns ETrue if there were any strongly directional 

characters and EFalse if there were none. If a piece of text is spread over 

several descriptors, They need to be queried in sequence until one returns 

ETrue in aFound. 

@return The directionality implicit in aText. 131 */ 

EXPORT_C TBidiText::TDirectionality TBidiText::TextDirectionality(

	const TDesC& aText, TBool* aFound)

	{

	return BidiCopy::ImplicitDirectionalityIsRightToLeft(

		aText.Ptr(), aText.Length(), aFound)?

		ERightToLeft : ELeftToRight;

	}

/** Creates a bidirectional text object with directionality determined by

aDirectionality. Use this for text that has come from user input.

@param aText The text in logical order.

@param aMaxLines

	The maximum number of lines that this text will need to be split into. Must

	be at least 1, but should not be too large, as each potential line takes an

	extra 8 bytes of memory.

@param aDirectionality Direction to use.

@return The newly constructed object.

 */

EXPORT_C TBidiText* TBidiText::NewL(const TDesC& aText, TInt aMaxLines,

	TBidiText::TDirectionality aDirectionality)

	{

	__ASSERT_ALWAYS(0 < aMaxLines, BidiPanic(EBidiPanic_InvalidMaxline));

	const TText* text = aText.Ptr();

	const TInt length = aText.Length();

	TInt linesInOriginalText = NumberOfLines(text, text + length);

	if (aMaxLines < linesInOriginalText)

		aMaxLines = linesInOriginalText;

	const TInt arraySize = TBidirectionalState::GenerateBdRunArray(text, length, 0, 0);

	TBidirectionalState::TRunInfo* runInfoArray = new(ELeave) TBidirectionalState::TRunInfo[arraySize];

	TCleanupItem ci(DeleteTRunInfo, runInfoArray);

	CleanupStack::PushL(ci);

	TBidirectionalState::GenerateBdRunArray(text, length, runInfoArray, arraySize);

	TBidirectionalState state;

	state.ReorderLine(runInfoArray, arraySize, ETrue, ETrue, aDirectionality,

		TChar::EOtherNeutral, TChar::EOtherNeutral);

	TInt compactArraySize = TRunInfoCompact::Convert(0, aText, runInfoArray, arraySize);

	// size of TBidiTextImp class

	TBidiTextImp* me = TBidiTextImp::NewL(length, aMaxLines, compactArraySize);

	me->SetRightToLeftDirectionality(aDirectionality != ELeftToRight);

	TRunInfoCompact::Convert(me->BidiRunArray(), aText, runInfoArray, arraySize);

	CleanupStack::PopAndDestroy(runInfoArray);

	Mem::Copy(me->LogicalText(), text, length * sizeof(TText));

	return me;

	}

/** Creates a bidirectional text object with directionality determined by the text 

itself. Use this for text that has been obtained from a resource file. 

@param aText The text in logical order.

@param aMaxLines The maximum number of lines that this text will need to be 

split into. Must be at least 1, but should not be too large, as each potential 

line takes an extra 8 bytes of memory.

@return The newly constructed object. */

EXPORT_C TBidiText* TBidiText::NewL(const TDesC& aText, TInt aMaxLines)

	{

	return NewL(aText, aMaxLines, TextDirectionality(aText));

	}

/** Creates a bidirectional text object with enough room for up to aReservedMaxLength

number of characters. The number of characters that will actually fit (when calling 

SetText()) might be slightly less than aReservedMaxLength, as each change between a 

left-to-right and a right-to-left sub-string (and the other way around) needs about

two characters worth of memory.

@param aReservedMaxLength The maximum number of characters.

@param aMaxLines The maximum number of lines that this text will need to be 

split into. Must be at least 1, but should not be too large, as each potential 

line takes an extra 8 bytes of memory.

@return The newly constructed object. */

EXPORT_C TBidiText* TBidiText::NewL(TInt aReservedMaxLength, TInt aMaxLines)

	{

	__ASSERT_ALWAYS(0 < aReservedMaxLength, BidiPanic(EBidiPanic_InvalidReservedMaxLength));

	__ASSERT_ALWAYS(0 < aMaxLines,          BidiPanic(EBidiPanic_InvalidMaxline));

	const TInt compactArraySize = 1;	// Always at least one needed

	TBidiTextImp* me = TBidiTextImp::NewL(aReservedMaxLength, aMaxLines, compactArraySize);

	me->SetTextLength(0);	// no text yet, just reserved memory

	return me;

	}

/** Sets the text of the bidirectional text object with directionality determined 

by the text itself. Use this for text that has been obtained from a resource file. 

@param aText The text in logical order.

@return The number of characters that didn't fit in the available buffer.

*/

EXPORT_C TInt TBidiText::SetText(const TDesC& aText, RRunInfoArray& aRunInfoArray)

	{

	return SetText(aText, TextDirectionality(aText), aRunInfoArray);

	}

/** Sets the text of the bidirectional text with directionality determined by

aDirectionality. Use this for text that has come from user input.

@param aText The text in logical order.

@param aDirectionality Direction to use.

@return The number of characters that didn't fit in the available buffer.

@panic Bidi EBidiPanic_RunArrayNull The call to RRunInfoArray::OpenL() has not

been made prior to this call to TBidiText::SetText()

*/

EXPORT_C TInt TBidiText::SetText(const TDesC& aText,

								 TDirectionality aDirectionality, 

								 RRunInfoArray& aRunInfoArray)

	{

	TBidirectionalState::TRunInfo* const runArray = aRunInfoArray.RunArray();

	__ASSERT_ALWAYS(runArray, BidiPanic(EBidiPanic_RunArrayNull));

	TBidiTextImp* me = TBidiTextImp::Imp(this);

	const TInt maxLines = me->iLines;	

	const TText* text = aText.Ptr();

	TInt length = aText.Length();

	TInt requiredArraySize = TBidirectionalState::GenerateBdRunArray(text, length, 0, 0);

	const TInt actualArraySize = aRunInfoArray.iTls->MaxArraySize();

	if (requiredArraySize > actualArraySize)

		{

		// Handle the case where we do not have enough space in the run array

		// to cope with the input text. The text will be truncated to ensure

		// we don't overrun the buffer and the number of excess characters 

		// returned as a negative number.

		requiredArraySize = actualArraySize;

		TBidirectionalState::GenerateBdRunArray(text, length, runArray, requiredArraySize);

		length = 0;

		for (TInt index = 0; index < requiredArraySize; index++)

			{

			length += runArray[index].iLength;

			}

		}

	else

		{

		TBidirectionalState::GenerateBdRunArray(text, length, runArray, requiredArraySize);

		}

	TBidirectionalState state;

	state.ReorderLine(runArray, 

					  requiredArraySize, 

					  ETrue, 

					  ETrue, 

					  aDirectionality, 

					  TChar::EOtherNeutral, 

					  TChar::EOtherNeutral);

	const TInt compactArraySize = TRunInfoCompact::Convert(0, 

														   aText, 

														   runArray, 

														   requiredArraySize);