// Copyright (c) 1997-2009 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 <conarc.h>

#include <s32file.h>

#include <e32std.h>

#include <e32uid.h>

#include "TXCONV.H"

//

// class CEtToTxtCnv

// 

CEtToTxtCnv::~CEtToTxtCnv()

	{

	delete iTextTranFromEra;

	}

void CEtToTxtCnv::ConvertObjectAL(RReadStream& aReadStream, RWriteStream& aWriteStream,MConverterUiObserver* /*aObserver*/)

	{

	iReadStream = &aReadStream;

	iPos=0;

	iLength=aReadStream.Source()->SizeL();

	delete iTextTranFromEra;

	iTextTranFromEra=NULL;

	iTextTranFromEra=TTextTranFromEra::NewL(CPlainText::EOrganiseByParagraph, aWriteStream,0);

	}

const TInt KBufSize=256;

TBool CEtToTxtCnv::DoConvertL()

	{

	__ASSERT_DEBUG(iTextTranFromEra, User::Invariant());

	TBuf<KBufSize> buf;

	TInt read = Min(iLength - iPos, KBufSize);

#if defined _UNICODE

	TBuf8<KBufSize> buf8;

	iReadStream->ReadL(buf8, read);

	for(TInt i = 0; i < (buf8.Size() - 1); i += 2)

		{

		buf.Append(buf8[i] | (buf8[i + 1] << 8));

		}

#else

	iReadStream->ReadL(buf,read);

#endif

	iPos += read;

	iTextTranFromEra->Initialise(buf);

	return iTextTranFromEra->DoTranslateL();

	}

TUid CEtToTxtCnv::Uid()

	{

	return KUidEtextToText;

	}

TInt CEtToTxtCnv::Capabilities()

	{

	return EConvertsObjects;

	}

CEtToTxtCnv::CEtToTxtCnv()

	{}

//

// class CTxtToEtCnv

// 

CTxtToEtCnv::~CTxtToEtCnv()

	{

	delete iTextTranToEra;

	}

void CTxtToEtCnv::ConvertObjectAL(RReadStream& aReadStream, RWriteStream& aWriteStream, MConverterUiObserver* /*aObserver*/)

	{

	iReadStream = &aReadStream;

	iWriteStream = &aWriteStream;

	iLength=iReadStream->Source()->SizeL();

	iPos=0;

	delete iTextTranToEra;

	iTextTranToEra=NULL;

	iTextTranToEra=new(ELeave) TTextTranToEra(CPlainText::EOrganiseByParagraph, iNoTrim);

	}

TBool CTxtToEtCnv::DoConvertL()

	{

	__ASSERT_DEBUG(iTextTranToEra, User::Invariant());

	TBuf<KBufSize> buf;

	TInt read = Min(iLength - iPos, KBufSize);

#if defined _UNICODE

	TBuf8<KBufSize> buf8;

	iReadStream->ReadL(buf8, read);

	TInt i = 0;

	for(; i < (buf8.Size() - 1); i += 2)

		{

		buf.Append(buf8[i] | (buf8[i + 1] << 8));

		}

#else

	iReadStream->ReadL(buf, read);

#endif

	iPos += read;

	iTextTranToEra->Translate(buf);

#if defined _UNICODE

	buf8.Zero();

	for (i = 0; i < buf.Length(); i++)

		{

		buf8.Append(buf[i] & 0x00FF);

		buf8.Append((buf[i] >> 8) & 0x00FF);

		}

	iWriteStream->WriteL(buf8);	

#else

	iWriteStream->WriteL(buf);

#endif

	if (iPos < iLength)

		return ETrue; // more to do

	return EFalse;

	}

TUid CTxtToEtCnv::Uid()

	{

	return KUidTextToEtext;

	}

TInt CTxtToEtCnv::Capabilities()

	{

	return EConvertsObjects;

	}

CTxtToEtCnv::CTxtToEtCnv()

	{}

CTxtToEtCnv::CTxtToEtCnv(TBool aNoTrim) : iNoTrim(aNoTrim)

	{}

TTextTran::TTextTran(CPlainText::TTextOrganisation aTextOrganisation)

// C'tor

//

	: iTransMode(aTextOrganisation)

	{}

void TTextTran::SetTranslationMode(CPlainText::TTextOrganisation aTextOrganisation)

//

	{iTransMode=aTextOrganisation;}

CPlainText::TTextOrganisation TTextTran::TranslationMode()const

//

	{return iTransMode;}

TTextTranToEra::TTextTranToEra(CPlainText::TTextOrganisation aTextOrganisation, TBool aNoTrim)

// C'tor

//

	: TTextTran(aTextOrganisation)

	{

	iNoTrim=aNoTrim;

	}

void TTextTranToEra::Translate(TDes& aBuf)

// Scans the passed buffer, replacing line delimiters with paragraph delimiters

// based on the translation mode that has been set. (Paragraph or line).

// Control characters in the source, that have meaning to ERA text are translated

// into 'blobs'.

// The descriptor aBuf will never be enlarged, only made smaller!

//

// Unicode specifies discontinuous control code regions.!!!

	{

	iReadPtr=CONST_CAST(TText*,aBuf.Ptr());

	iWritePtr=CONST_CAST(TText*,iReadPtr);

	const TText* basePtr=iReadPtr;

	const TInt length=aBuf.Length();

	while (iReadPtr<basePtr+length)

		{

//		__ASSERT_DEBUG(iReadPtr>=iWritePtr,Panic(EDebug));

		if (*iReadPtr<0x20)

			MapControlCode();  // This is a control character

		else

			{

			*iWritePtr=*iReadPtr;

			iWritePtr++;

			}

		iReadPtr++;

		}

	aBuf.SetLength(iWritePtr-basePtr);

	}

void TTextTranToEra::MapControlCode()

// Translate any control codes encountered into something more reasonable.

// CR's are ignored completely, only LF's influence where paragraph delimiters occur.

//

	{

	switch (*iReadPtr)

		{

		case 0x0c:  // FF

			*iWritePtr=CEditableText::EPageBreak;

			break;

		case 0x09:  // CEditableText::ETabCharacter

			*iWritePtr=*iReadPtr;

			break;  // No translation required

		case 0x0d:  // CR - ignore this character.

			iWritePtr--;  // cos its incremented again outside the switch.

			break;

		case 0x0a:  // LF

			{

			if (iTransMode==CPlainText::EOrganiseByParagraph)

				{

				if(!iNoTrim)

					{

					Trim();  // trims trailng white space preceeding this line delimter.

					}

				*iWritePtr=CEditableText::EParagraphDelimiter;  // all line delimiters become paragraph delimiters

				}

			else

				{// only consecutive line delimiters become paragraph delimiters

				if (*(iReadPtr+1)==0x0a || (*(iReadPtr+1)==0x0d && *(iReadPtr+2)==0x0a))

					{

					Trim();  // trims trailng white space preceeding this line delimter.

					*iWritePtr=CEditableText::EParagraphDelimiter;  // Insert paragraph

					iReadPtr+=(*(iReadPtr+1)==0x0a) ? 1 : 2; // consume this delimiter set.

					}

				else

					*iWritePtr=0x20;  // replace with white space.

				}

			break;

			}

		default:

			// CEditableText::EParagraphDelimiter

			// CEditableText::ELineBreak

			// CEditableText::EPageBreak

			// CEditableText::ENonBreakingTab

			// CEditableText::ENonBreakingHyphen

			// CEditableText::EPotentialHyphen

			// CEditableText::ENonBreakingSpace

			// CEditableText::EPictureCharacter

			*iWritePtr=*iReadPtr;

			break;

		}

	iWritePtr++;

	}

void TTextTranToEra::Trim()

// Removes white space that has already been written before the line delimiter was encountered.

//

	{

	while (*(iWritePtr-1)==0x20)

		iWritePtr--;

	}

TTextTranFromEra* TTextTranFromEra::NewL(CPlainText::TTextOrganisation aTextOrganisation,RWriteStream& aOutStream,TInt aLineWrap)

// Create & initialise a new instance of this class.

//

	{

	TTextTranFromEra* self=new(ELeave) TTextTranFromEra(aTextOrganisation,aOutStream,aLineWrap);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

TTextTranFromEra::TTextTranFromEra(CPlainText::TTextOrganisation aTextOrganisation,RWriteStream& aOutStream,TInt aLineWrap)

// C'tor

//

	: TTextTran(aTextOrganisation),iOutStream(aOutStream),iLineWrap(aLineWrap)

	{

	ResetExportBuffer();

	if (aTextOrganisation==CPlainText::EOrganiseByParagraph)

		iLineWrap=KMaxTInt;

	}

void TTextTranFromEra::ConstructL()

// Initialise this object.

//

	{}

TInt TTextTranFromEra::DoTranslateL()

// Scans the passed buffer, replacing paragraph delimiters with line delimiters (CR/LF)

// based on the translation mode that has been set. (Paragraph or line).

// Special characters in the source, that have meaning to ERA text are translated.

//

	{

	if(iReadPtr<iSBase+iSLen)

		{

		while (iReadPtr<(iSBase+iSLen))

			{

			DoTranslateSourceBufferL();  // returns when export buffer is full or aBuf is empty

			CommitExportBufferToFileL();  // export buffer full

			}

		return ETrue;

		}

	CommitExportBufferToFileL();

	return EFalse;

	}

void TTextTranFromEra::NotifyEndOfSourceL()

// Flush the export buffer.

//

	{CommitExportBufferToFileL();}

void TTextTranFromEra::Initialise(const TDesC& aBuf)

//

	{

	iReadPtr=CONST_CAST(TText*,aBuf.Ptr());

	iSBase=iReadPtr;

	iSLen=aBuf.Length();

	}

void TTextTranFromEra::ResetExportBuffer()

//

	{

	iWritePtr=CONST_CAST(TText*,iExportBuffer.Ptr());

	iTBase=iWritePtr;

	}

void TTextTranFromEra::CommitExportBufferToFileL()

//

	{

	iExportBuffer.SetLength(iWritePtr - iTBase);

#if !defined(_UNICODE)

	iOutStream.WriteL(iExportBuffer);

#else // Write wide descriptor to file as byte stream

	TBuf8<KMaxExportBuffer> narrowBuffer;

	TInt i = 0;

	for (; i < (iExportBuffer.Length() / 2); i++)

		{

		narrowBuffer.Append(iExportBuffer[i] & 0x00FF);

		narrowBuffer.Append((iExportBuffer[i] >> 8) & 0x00FF);

		}

	iOutStream.WriteL(narrowBuffer);

	narrowBuffer.Zero();

	for (i = (iExportBuffer.Length() / 2); i < iExportBuffer.Length(); i++)

		{

		narrowBuffer.Append(iExportBuffer[i] & 0x00FF);

		narrowBuffer.Append((iExportBuffer[i] >> 8) & 0x00FF);

		}

	iOutStream.WriteL(narrowBuffer);

#endif

	iExportBuffer.SetLength(0);

	iWritePtr = iTBase;  // Reset the write pointer - fundamental !!!!

	}

void TTextTranFromEra::DoTranslateSourceBufferL()

// Translate the source buffer, writing to the export buffer.

// Returns when either the source has been consumed or the export buffer is full

//

	{

	while (iReadPtr<iSBase+iSLen && iWritePtr<iTBase+KMaxExportBuffer-2*KLineDelimiterLength)

		{

		if ((*iReadPtr<0x20) || (*iReadPtr==CEditableText::EParagraphDelimiter))

			MapEraCodeL();  // May fill export buffer

		else

			{

			*iWritePtr=*iReadPtr;

			iWritePtr++;

			}

		if (iLineWrap!=KMaxTInt && iWritePtr>=iTBase+iLineWrap)

			{

			TText* ptr=iWritePtr;

			TText* end=iWritePtr;

			TText chr(0);

			while ((*(--ptr))!=' ' && ptr>iTBase)		//Allow for more general breaking character

				{}

			if (*ptr!=' ')

				{

				WriteCRLF(KLineDelimiterLength);

				ptr=end;		//So the while below is not executed

				}

			else

				{

				*ptr++=KCharacterCR;

				chr=*ptr;

				*ptr++=KCharacterLF;

				iWritePtr=ptr;

				}

			CommitExportBufferToFileL();

			if (ptr<=end)

				{

				*(iWritePtr++)=chr;

				while (ptr<end)

					{

					*(iWritePtr++)=*(ptr++);

					}

				}

			}

		iReadPtr++;

		}

	}

void TTextTranFromEra::MapEraCodeL()

//

	{

	switch (*iReadPtr)

		{

		case CEditableText::EPictureCharacter:

		case CEditableText::ELineBreak:

		case CEditableText::EPageBreak:

		case CEditableText::EPotentialHyphen:

			return;  // These characters are not emitted.

		case CEditableText::ETabCharacter:

			*iWritePtr=KCharacterTab;

			break;

		case CEditableText::ENonBreakingHyphen:

			*iWritePtr=KCharacterHyphen;

			break;

		case CEditableText::ENonBreakingSpace:

			*iWritePtr=KCharacterSpace;

			break;

		case CEditableText::EParagraphDelimiter:

			{

			TInt charsToWrite=KLineDelimiterLength;

			if (iTransMode==CPlainText::EOrganiseByLine)

				charsToWrite=2*KLineDelimiterLength;

			WriteCRLF(charsToWrite);

			if (iTransMode==CPlainText::EOrganiseByLine)

				CommitExportBufferToFileL();  // export buffer

			return;

			}

		default:

			*iWritePtr=*iReadPtr;

			break;

		}

	iWritePtr++;

	}

void TTextTranFromEra::WriteCRLF(TInt aNumCharacters)

//

	{

	while (aNumCharacters>0)

		{

		if (aNumCharacters%2==1)

			*iWritePtr=KCharacterLF;

		else

			*iWritePtr=KCharacterCR;

		aNumCharacters--;

		iWritePtr++;

		}

	}