// text_formatter.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <e32base.h>

#include "ioutils.h"

#include "pod_lexer.h"

#include "pod_formatter.h"

using namespace IoUtils;

//

// Constants.

//

_LIT(KSpace, " ");

_LIT(KNewLine, "\r\n");

//

// CTextBuffer.

//

EXPORT_C CTextBuffer* CTextBuffer::NewL(TInt aExpandSize)

	{

	CTextBuffer* self = CTextBuffer::NewLC(aExpandSize);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CTextBuffer* CTextBuffer::NewLC(TInt aExpandSize)

	{

	CTextBuffer* self = new(ELeave) CTextBuffer();

	CleanupStack::PushL(self);

	self->ConstructL(aExpandSize);

	return self;

	}

EXPORT_C CTextBuffer::~CTextBuffer()

	{

	Cancel();

	delete iBuf;

	delete iScratchBuf;

	delete iScratchBuf8;

	iAttributes.Close();

	}

EXPORT_C void CTextBuffer::Zero()

	{

	iBuf->Delete(0, iBuf->Size());

	iAttributes.Reset();

	}

EXPORT_C void CTextBuffer::Reset()

	{

	iBuf->Reset();

	iAttributes.Reset();

	}

EXPORT_C void CTextBuffer::ResetText()

	{

	iBuf->Reset();

	}

EXPORT_C void CTextBuffer::SetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor)

	{

	const TInt numAttributes = iAttributes.Count();

	if (numAttributes == 0)

		{

		if (Length() == 0)

			{

			TAttributes attributes(0, aAttributes, aForegroundColor, aBackgroundColor);

			iAttributes.AppendL(attributes);

			}

		else

			{

			TAttributes attributes(Length(), aAttributes, aForegroundColor, aBackgroundColor);

			if (!attributes.Matches(ConsoleAttributes::ENone, ConsoleAttributes::EUnchanged, ConsoleAttributes::EUnchanged))

				{

				TAttributes defaultAttributes(0, ConsoleAttributes::ENone, ConsoleAttributes::EUnchanged, ConsoleAttributes::EUnchanged);

				iAttributes.AppendL(defaultAttributes);

				TInt err = iAttributes.Append(attributes);

				if (err != KErrNone)

					{

					iAttributes.Reset();

					User::Leave(err);

					}

				}

			}

		}

	else if (iAttributes[numAttributes - 1].Matches(aAttributes, aForegroundColor, aBackgroundColor))

		{

		// Do nothing.

		}

	else if (iAttributes[numAttributes - 1].iPosition == Length())

		{

		TAttributes& att = iAttributes[numAttributes - 1];

		if (aAttributes & ConsoleAttributes::ENone)

			{

			att.iAttributes.iAttributes = aAttributes;

			att.iAttributes.iForegroundColor = aForegroundColor;

			att.iAttributes.iBackgroundColor = aBackgroundColor;

			}

		else

			{

			// Merge on top of existing attributes

			att.iAttributes.iAttributes |= aAttributes;

			if (aForegroundColor != ConsoleAttributes::EUnchanged) att.iAttributes.iForegroundColor = aForegroundColor;

			if (aBackgroundColor != ConsoleAttributes::EUnchanged) att.iAttributes.iBackgroundColor = aBackgroundColor;

			}

		}

	else

		{

		TAttributes attributes(Length(), aAttributes, aForegroundColor, aBackgroundColor);

		iAttributes.AppendL(attributes);

		}

	}

EXPORT_C void CTextBuffer::SetAttributesL(const ConsoleAttributes::TAttributes& aAttributes)

	{

	SetAttributesL(aAttributes.iAttributes, aAttributes.iForegroundColor, aAttributes.iBackgroundColor);

	}

EXPORT_C void CTextBuffer::GetCurrentAttributes(TUint& aAttributes, ConsoleAttributes::TColor& aForegroundColor, ConsoleAttributes::TColor& aBackgroundColor) const

	{

	if (iAttributes.Count() > 0)

		{

		const TAttributes& att = iAttributes[iAttributes.Count() - 1];

		aAttributes = att.iAttributes.iAttributes;

		aForegroundColor = att.iAttributes.iForegroundColor;

		aBackgroundColor = att.iAttributes.iBackgroundColor;

		}

	else

		{

		aAttributes = ConsoleAttributes::ENone;

		aForegroundColor = ConsoleAttributes::EUnchanged;

		aBackgroundColor = ConsoleAttributes::EUnchanged;

		}

	}

EXPORT_C void CTextBuffer::GetAttributes(TInt aPos, TUint& aAttributes, ConsoleAttributes::TColor& aForegroundColor, ConsoleAttributes::TColor& aBackgroundColor) const

	{

	ASSERT(aPos < Length());

	aAttributes = ConsoleAttributes::ENone;

	aForegroundColor = ConsoleAttributes::EUnchanged;

	aBackgroundColor = ConsoleAttributes::EUnchanged;

	const TInt numAttributes = iAttributes.Count();

	for (TInt i = 0; i < numAttributes; ++i)

		{

		const TAttributes& att = iAttributes[i];

		if (aPos < att.iPosition)

			{

			return;

			}

		else

			{

			aAttributes = att.iAttributes.iAttributes;

			aForegroundColor = att.iAttributes.iForegroundColor;

			aBackgroundColor = att.iAttributes.iBackgroundColor;

			}

		}

	}

EXPORT_C void CTextBuffer::AppendL(const TChar& aChar)

	{

	TUint16 ch = (TUint16)TUint(aChar); // We don't support surrogate pairs

	iBuf->InsertL(iBuf->Size(), &ch, 2);

	}

EXPORT_C void CTextBuffer::AppendL(const TDesC& aText)

	{

	iBuf->InsertL(iBuf->Size(), aText.Ptr(), aText.Size());

	}

EXPORT_C void CTextBuffer::AppendL(const TDesC8& aText)

	{

	if (!iScratchBuf)

		{

		iScratchBuf = HBufC::NewL(Max(aText.Length(), 256));

		}

	if (iScratchBuf->Des().MaxLength() < aText.Length())

		{

		iScratchBuf = iScratchBuf->ReAllocL(Max(iScratchBuf->Des().MaxLength()*2, aText.Length()));

		}

	iScratchBuf->Des().Copy(aText);	

	iBuf->InsertL(iBuf->Size(), iScratchBuf->Ptr(), iScratchBuf->Size());

	}

EXPORT_C void CTextBuffer::AppendL(const CTextBuffer& aText)

	{

	AppendL(aText, 0, aText.Length());

	}

EXPORT_C void CTextBuffer::AppendL(const CTextBuffer& aText, TInt aPosition)

	{

	AppendL(aText, aPosition, aText.Length() - aPosition);

	}

EXPORT_C void CTextBuffer::AppendL(const CTextBuffer& aText, TInt aPosition, TInt aLength)

	{

	const TInt numAttributes = aText.iAttributes.Count();

	if (numAttributes > 0)

		{

		TInt textPos = 0;

		TInt appendCount = 0;

		TInt blockIndex = 0;

		const TDesC* block = NULL;

		do

			{

			TUint attributes;

			ConsoleAttributes::TColor foregroundColor;

			ConsoleAttributes::TColor backgroundColor;

			aText.NextBlock(blockIndex, block, attributes, foregroundColor, backgroundColor);

			if (block != NULL)

				{

				if ((textPos + block->Length()) > aPosition)

					{

					SetAttributesL(attributes, foregroundColor, backgroundColor);

					TInt blockOffset = aPosition - textPos;

					if (blockOffset < 0)

						{

						blockOffset = 0;

						}

					TPtrC appendBlock(block->Mid(blockOffset, Min(aLength - appendCount, block->Length() - blockOffset)));

					AppendL(appendBlock);

					appendCount += appendBlock.Length();

					if (appendCount == aLength)

						{

						break;

						}

					}

				textPos += block->Length();

				}

			}

			while (block != NULL);

		}

	else

		{

		AppendL(aText.Descriptor().Mid(aPosition, aLength));

		}

	}

EXPORT_C void CTextBuffer::AppendFormatL(TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	AppendFormatListL(aFmt, list);

	}

EXPORT_C void CTextBuffer::AppendFormatListL(const TDesC16& aFmt, VA_LIST& aList)

	{

	TOverflowLeave overflow;

	TInt err = KErrNone;

	do

		{

		TPtr ptr(iScratchBuf->Des());

		ptr.Zero();

		TRAP(err, ptr.AppendFormatList(aFmt, aList, &overflow));

		if (err == KErrOverflow)

			{

			iScratchBuf = iScratchBuf->ReAllocL(ptr.MaxLength() * 2);

			}

		}

		while (err == KErrOverflow);

	User::LeaveIfError(err);

	iBuf->InsertL(iBuf->Size(), iScratchBuf->Ptr(), iScratchBuf->Size());

	}

EXPORT_C void CTextBuffer::AppendFormatL(TRefByValue<const TDesC8> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	AppendFormatListL(aFmt, list);

	}

EXPORT_C void CTextBuffer::AppendFormatListL(const TDesC8& aFmt, VA_LIST& aList)

	{

	TOverflowLeave8 overflow;

	TInt err = KErrNone;

	if (!iScratchBuf8)

		{

		iScratchBuf8 = HBufC8::NewL(0x100);

		}

	do

		{

		TPtr8 ptr(iScratchBuf8->Des());

		ptr.Zero();

		TRAP(err, ptr.AppendFormatList(aFmt, aList, &overflow));

		if (err == KErrOverflow)

			{

			iScratchBuf8 = iScratchBuf8->ReAllocL(ptr.MaxLength() * 2);

			}

		}

		while (err == KErrOverflow);

	User::LeaveIfError(err);

	TPtr8 ptr(iScratchBuf8->Des());

	if (iScratchBuf->Des().MaxLength() < ptr.Length())

		{

		iScratchBuf = iScratchBuf->ReAllocL(Max(iScratchBuf->Des().MaxLength()*2, ptr.Length()));

		}

	iScratchBuf->Des().Copy(*iScratchBuf8);	

	iBuf->InsertL(iBuf->Size(), iScratchBuf->Ptr(), iScratchBuf->Size());

	}

EXPORT_C void CTextBuffer::AppendHumanReadableSizeL(TInt aSize)

	{

	AppendHumanReadableSizeL(TInt64(aSize), EColumnAlignedRight);

	}

EXPORT_C void CTextBuffer::AppendHumanReadableSizeL(TInt64 aSize)

	{

	AppendHumanReadableSizeL(aSize, EColumnAlignedRight);

	}

EXPORT_C void CTextBuffer::AppendHumanReadableSizeL(TInt aSize, TAlignment aAlignment)

	{

	AppendHumanReadableSizeL(TInt64(aSize), aAlignment);

	}

EXPORT_C void CTextBuffer::AppendHumanReadableSizeL(TInt64 aSize, TAlignment aAlignment)

	{

	const TInt64 KB = 1024;

	const TInt64 MB = KB * KB;

	const TInt64 GB = MB * KB;

	const TInt64 TB = GB * KB;

	_LIT(KBytes, " B ");

	_LIT(KKilobytes, " KB");

	_LIT(KMegabytes, " MB");

	_LIT(KGigabytes, " GB");

	_LIT(KTerabytes, " TB");

	_LIT(KLeftWhole, "%- 7.0f");

	_LIT(KLeftFrac, "%- 7.2f");

	_LIT(KRightWhole, "%+ 7.0f");

	_LIT(KRightFrac, "%+ 7.2f");

	_LIT(KNormalWhole, "%.0f");

	_LIT(KNormalFrac, "%.2f");

	const TDesC* suff = &KBytes;

	TReal n = aSize;

	TInt64 factor = 1;

	TInt64 absSize = aSize;

	if (absSize < 0) absSize = -absSize;

	if (absSize >= TB)

		{

		suff = &KTerabytes;

		factor = TB;

		}

	else if (absSize >= GB)

		{

		suff = &KGigabytes;

		factor = GB;

		}

	else if (absSize >= MB)

		{

		suff = &KMegabytes;

		factor = MB;

		}

	else if (absSize >= KB)

		{

		suff = &KKilobytes;

		factor = KB;

		}

	n = n / (TReal)factor;

	TBool wholeNumUnits = (absSize & (factor-1)) == 0; // ie aSize % factor == 0

	const TDesC* fmt = NULL;

	if (aAlignment == EColumnAlignedLeft)

		{

		fmt = wholeNumUnits ? &KLeftWhole : &KLeftFrac;

		}

	else if (aAlignment == EColumnAlignedRight)

		{

		fmt = wholeNumUnits ? &KRightWhole : &KRightFrac;

		}

	else

		{

		fmt = wholeNumUnits ? &KNormalWhole : &KNormalFrac;

		}

	AppendFormatL(*fmt, n);

	AppendL(*suff);

	}

EXPORT_C void CTextBuffer::AppendSpacesL(TInt aCount)

	{

	ASSERT(aCount >= 0);

	while (aCount > 0)

		{

		AppendL(KSpace);

		--aCount;

		}

	}

EXPORT_C void CTextBuffer::Delete(TInt aPos, TInt aLength)

	{

	//for (TInt i = 0; i < iAttributes.Count(); i++)

	//	{

	//	RDebug::Printf("attribute %d: pos %d", i, iAttributes[i].iPosition);

	//	}

	// Find the first and last attributes that are inside the delete region.

	TInt firstAttribute = -1;

	TInt lastAttribute = -1;

	TInt numAttributes = iAttributes.Count();

	for (TInt i = (numAttributes - 1); i >= 0; --i)

		{

		const TAttributes& thisAttribute = iAttributes[i];

		if ((lastAttribute == -1) && (thisAttribute.iPosition >= aPos) && (thisAttribute.iPosition < aPos + aLength))

			{

			lastAttribute = i;

			}

		if (lastAttribute >= 0 && thisAttribute.iPosition >= aPos)

			{

			firstAttribute = i;

			}

		}

	//RDebug::Printf("firstAttribute=%d lastAttribute=%d", firstAttribute, lastAttribute);

	if ((lastAttribute > 0))

		{

		// Set the position of the last affected attribute to just after the deleted chunk.

		iAttributes[lastAttribute].iPosition = aPos + aLength;

		// Remove all but the last affected attribute. Need to keep the last affected attribute

		// because it has an impact on the formatting of text that appears after the deleted chunk.

		for (TInt i = (lastAttribute - 1); i >= firstAttribute; --i)

			{

			iAttributes.Remove(i);

			}

		}

	// Update the positions of attributes after the block being deleted.

	numAttributes = iAttributes.Count();

	for (TInt i = Max(0, firstAttribute); i < numAttributes; ++i)

		{

		TAttributes& thisAttribute = iAttributes[i];

		if (thisAttribute.iPosition >= aPos + aLength)

			{

			thisAttribute.iPosition -= aLength;

			}

		}

	iBuf->Delete(aPos * 2, aLength * 2);

	}

EXPORT_C TInt CTextBuffer::Length() const

	{

	return iBuf->Size() / 2;

	}

EXPORT_C const TDesC& CTextBuffer::Descriptor() const

	{

	TPtr8 narrowPtr(iBuf->Ptr(0));

	iPtr.Set((const TUint16 *)narrowPtr.Ptr(), narrowPtr.Length() / 2);

	return iPtr;

	}

EXPORT_C const TDesC& CTextBuffer::Descriptor(TInt aPos, TInt aLength) const

	{

	TPtr8 narrowPtr(iBuf->Ptr(aPos * 2));

	iPtr.Set((const TUint16 *)narrowPtr.Ptr(), aLength);

	return iPtr;

	}

EXPORT_C TPtrC8 CTextBuffer::Collapse()

	{

	TPtr8 narrowPtr(iBuf->Ptr(0));

	TPtr ptr((TUint16 *)narrowPtr.Ptr(), narrowPtr.Length() / 2, narrowPtr.Length() / 2);

	return ptr.Collapse();

	}

EXPORT_C TInt CTextBuffer::Write(RIoWriteHandle& aWriteHandle) const

	{

	return Write(aWriteHandle, 0, Length());

	}

EXPORT_C void CTextBuffer::Write(RIoWriteHandle& aWriteHandle, TRequestStatus& aStatus) const

	{

	Write(aWriteHandle, 0, Length(), aStatus);

	}

EXPORT_C TInt CTextBuffer::Write(RIoWriteHandle& aWriteHandle, TInt aPosition, TInt aLength) const

	{

	const TInt numAttributes = iAttributes.Count();

	if ((aWriteHandle.AttachedToConsole() > 0) && (numAttributes > 0))

		{

		// Write the text buffer to the console a block at a time, updating the console's attributes at the beginning of each block.

		TInt blockIndex = 0;

		TInt textPos = 0;

		TInt writeCount = 0;

		const TDesC* block = NULL;

		do

			{

			TUint attributes;

			ConsoleAttributes::TColor foregroundColor;

			ConsoleAttributes::TColor backgroundColor;

			NextBlock(blockIndex, block, attributes, foregroundColor, backgroundColor);

			if (block != NULL)

				{

				if ((textPos + block->Length()) > aPosition)

					{

					RIoConsoleWriteHandle(aWriteHandle).SetAttributes(attributes, foregroundColor, backgroundColor); // Ignore error - may not be supported.

					TInt blockOffset = aPosition - textPos;

					if (blockOffset < 0)

						{

						blockOffset = 0;

						}

					TPtrC toWrite(block->Mid(blockOffset, Min(aLength - writeCount, block->Length() - blockOffset)));

					TInt err = aWriteHandle.Write(toWrite);