/*

 * Copyright (c) 1998-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: 

 * Implementation of the classes that import and export plain text.

 *

 */

 #include "TXTSTD.H"

 #include "TXTPLAIN.H"

 #include "charconv.h"

 TPlainTextIOState::	TPlainTextIOState(const CPlainText::TImportExportParam& aParam,

 									  CPlainText::TImportExportResult& aResult,

 									  RWriteStream& aOutput,RReadStream& aInput):

 	iParam(aParam),

 	iResult(aResult),

 	iOutput(aOutput),

 	iInput(aInput),

 	iConverter(NULL),

 	iSwapInput(FALSE),

 	iCheckByteOrder(FALSE)

 	{

 	aResult = CPlainText::TImportExportResult();  // zero output counters; aResult may be re-used.

 	}

 TText TPlainTextIOState::ReadRawCharL()

 	{

 	TText c;

 	if (iParam.iInputInternal)

 		iInput.ReadL((TUint8*)&c,sizeof(TText));

 	else

 		c = iInput.ReadUint16L();

 	if (iSwapInput)

 		c = (TText)(((c << 8) & 0xFF00) | ((c >> 8) & 0xFF));

 	if (iCheckByteOrder)

 		{

 		if (c == CEditableText::EReversedByteOrderMark)

 			{

 			c = CEditableText::EByteOrderMark;

 			iSwapInput = !iSwapInput;

 			}

 		iCheckByteOrder = FALSE;

 		}

 	iResult.iInputChars++;

 	return c;

 	}

 void TPlainTextIOState::WriteRawCharL(TText aChar)

 	{

 	if (iResult.iOutputChars < iParam.iMaxOutputChars)

 		{

 		if (iParam.iOutputInternal)

 			iOutput.WriteL((TUint8*)&aChar,sizeof(TText));

 		else

 			iOutput.WriteUint16L(aChar);

 		iResult.iOutputChars++;

 		}

 	}

 CPlainTextConverter* CPlainTextConverter::NewLC()

 	{

 	CPlainTextConverter* c = new(ELeave) CPlainTextConverter;

 	CleanupStack::PushL(c);

 	c->iConversionBuffer = new(ELeave) TUint8[EConversionBufferSize];

 	return c;

 	}

 CPlainTextConverter::~CPlainTextConverter()

 	{

 	delete iConverter;

 	delete [] iConversionBuffer;

 	}

 /*

 Prepare to convert between Unicode and a foreign encoding.

 If aSample is non-null it can be used to guess the foreign encoding, but only if iParam.iGuessForeignEncoding is true.

 */

 void CPlainTextConverter::PrepareToConvertL(TPlainTextIOState& aState,const TDesC8* aSample)

 	{

 	RFs rfs;

 	iConverter = CCnvCharacterSetConverter::NewL();

 	if (aState.iParam.iFileSession == NULL)

 		{

 		TInt error = rfs.Connect();

 		User::LeaveIfError(error);

 		CleanupClosePushL(rfs);

 		}

 	else

 		rfs = *aState.iParam.iFileSession;

 	TUint foreign_encoding = aState.iParam.iForeignEncoding;

 	// Try to guess the foreign encoding.

 	if (aSample && aState.iParam.iGuessForeignEncoding)

 		{

 		CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* charsets =

 			CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(rfs);

 		TInt confidence = 0;

 		CCnvCharacterSetConverter::AutoDetectCharacterSetL(confidence,foreign_encoding,*charsets,*aSample);

 		CleanupStack::PopAndDestroy(charsets);

 		if (confidence < 50)

 			User::Leave(KErrNotSupported);

 		}

 	if (iConverter->PrepareToConvertToOrFromL(foreign_encoding,rfs) != CCnvCharacterSetConverter::EAvailable)

 		User::Leave(KErrNotSupported);

 	aState.iResult.iForeignEncoding = foreign_encoding;

 	if (aState.iParam.iFileSession == NULL)

 		{

 		CleanupStack::Pop(); // rfs

 		rfs.Close();

 		}

 	}

 void TPlainTextWriter::TranslateL(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,

 								  RWriteStream& aOutput,RReadStream& aInput)

 	{

 	TPlainTextWriter writer(aParam,aResult,aOutput,aInput);

 	writer.TranslateHelperL();

 	}

 TPlainTextWriter::TPlainTextWriter(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,

 								   RWriteStream& aOutput,RReadStream& aInput):

 	TPlainTextIOState(aParam,aResult,aOutput,aInput),

 	iLineLength(0),

 	iLineBuffer(NULL),

 	iMaxLineBufferLength(0)

 	{

 	}

 void TPlainTextWriter::TranslateHelperL()

 	{

 	if (iParam.iForeignEncoding)

 		{

 		iConverter = CPlainTextConverter::NewLC();

 		iConverter->PrepareToConvertL(*this,NULL);

 		}

 	if (iParam.iOrganisation == CPlainText::EOrganiseByLine)

 		iMaxLineLength = iParam.iMaxLineLength;

 	else

 		iMaxLineLength = KMaxTInt; // when exporting by paragraph, the wrapping width has no effect

 	if (iMaxLineLength <= 0)

 		iMaxLineLength = KMaxTInt;

 	iLineLength = 0;

 	if (iMaxLineLength < KMaxTInt)

 		iMaxLineBufferLength = iMaxLineLength;

 	else if (iParam.iForeignEncoding)

 		iMaxLineBufferLength = EDefaultLineBufferSize;

 	if (iMaxLineBufferLength)

 		iLineBuffer = new(ELeave) TText[iMaxLineBufferLength];

 	else

 		iLineBuffer = NULL;

 	CleanupStack::PushL(iLineBuffer);

 	TRAPD(error,TranslateToEofL());

 	if (error == KErrEof)

 		error = KErrNone;

 	if (error == KErrNone)

 		{

 		FlushL();

 		iOutput.CommitL();

 		}

 	CleanupStack::Pop(iLineBuffer);

 	delete [] iLineBuffer;

 	if (iConverter)

 		CleanupStack::PopAndDestroy(iConverter);

 	User::LeaveIfError(error);

 	}

 void TPlainTextWriter::TranslateToEofL()

 	{

 	while (!Finished())

 		{

 		TText c = ReadRawCharL();

 		switch (c)

 			{

 			// Write a CR-LF at a forced line break if organising by line.

 			case CEditableText::ELineBreak:

 				if (iParam.iOrganisation == CPlainText::EOrganiseByLine)

 					{

 					FlushL();

 					WriteNewLineL();

 					}

 				else

 					WriteCharL(c);

 				break;

 			// Write a CR-LF at the end of the paragraph, then an extra one if lines are split by CR-LFs.

 			case CEditableText::EParagraphDelimiter:

 				FlushL();

 				WriteNewLineL();

 				if (iParam.iOrganisation == CPlainText::EOrganiseByLine)

 					WriteNewLineL();

 				break;

 			default:

 				WriteCharL(c);

 			}

 		}

 	}

 void TPlainTextWriter::FlushL()

 	{

 	if (iLineBuffer)

 		WriteAndConvertL(iLineBuffer,iLineLength);

 	iLineLength = 0;

 	}

 void TPlainTextWriter::WriteCharL(TText aChar)

 	{

 	if (iLineBuffer)

 		{

 		if (iLineLength >= iMaxLineBufferLength)

 			{

 			int linebreak = iMaxLineBufferLength;

 			int stripped_linebreak = iMaxLineBufferLength;

 			if (iLineLength >= iMaxLineLength)

 				{

 				for (linebreak = iMaxLineLength; linebreak > 0; linebreak--)

 					if (iLineBuffer[linebreak - 1] == ' ')

 						break;

 				if (linebreak == 0)

 					linebreak = iMaxLineLength;

 				// Strip a single trailing space if any; it is added when text is imported.

 				stripped_linebreak = linebreak;

 				if (iLineBuffer[linebreak - 1] == ' ')

 					stripped_linebreak = linebreak - 1;

 				}

 			WriteAndConvertL(iLineBuffer,stripped_linebreak);

 			if (iLineLength >= iMaxLineLength)

 				WriteNewLineL();

 			int i = linebreak;

 			int j = 0;

 			while (i < iMaxLineBufferLength)

 				iLineBuffer[j++] = iLineBuffer[i++];

 			iLineLength = j;

 			}

 		iLineBuffer[iLineLength++] = aChar;

 		}

 	else

 		WriteRawCharL(aChar);

 	}

 void TPlainTextWriter::WriteNewLineL()

 	{

 	WriteAndConvertL(_S("\x0d\x0a"),2);

 	}

 void TPlainTextWriter::WriteAndConvertL(const TText* aText,TInt aLength)

 	{

 	if (iConverter)

 		{

 		while (aLength > 0)

 			{

 			TPtrC source(aText,aLength);

 			TPtr8 dest(iConverter->iConversionBuffer,CPlainTextConverter::EConversionBufferSize);

 			int remainder = iConverter->iConverter->ConvertFromUnicode(dest,source);

 			if (remainder < 0)

 				User::Leave(KErrCorrupt);

 			int available = iParam.iMaxOutputChars - iResult.iOutputChars;

 			if (available < dest.Length())

 				dest.SetLength(available);

 			if (dest.Length() > 0)

 				{

 				iOutput.WriteL(dest);

 				iResult.iOutputChars += dest.Length();

 				}

 			int converted = aLength - remainder;

 			aText += converted;

 			aLength -= converted;

 			}

 		}

 	else

 		{

 		while (aLength-- > 0)

 			WriteRawCharL(*aText++);

 		}

 	}

 TPlainTextReader::TPlainTextReader(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,

 								   RWriteStream& aOutput,RReadStream& aInput):

 	TPlainTextIOState(aParam,aResult,aOutput,aInput),

 	iInputBuffer(NULL),

 	iInputLength(0),

 	iInputPos(0),

 	iConversionState(CCnvCharacterSetConverter::KStateDefault)

 	{

 	iCheckByteOrder = TRUE;

 	}

 void TPlainTextReader::TranslateL(const CPlainText::TImportExportParam& aParam,CPlainText::TImportExportResult& aResult,

 								  RWriteStream& aOutput,RReadStream& aInput)

 	{

 	TPlainTextReader reader(aParam,aResult,aOutput,aInput);

 	if(reader.iParam.iOrganisation == CPlainText::EOrganiseByLine)

 		{

 		TLineTextWriter txtWriter(reader);

 		TSLBTransaltor slbTranslator(txtWriter);

 		reader.TranslateHelperL(slbTranslator);

 		}

 	else

 		{

 		TParagraphTextWriter txtWriter(reader);

 		TSLBTransaltor slbTranslator(txtWriter);

 		reader.TranslateHelperL(slbTranslator);

 		}

 	}

 void TPlainTextReader::TranslateHelperL(TSLBTransaltor& aSLBTranslator)

 	{

 	if (iParam.iForeignEncoding || iParam.iGuessForeignEncoding)

 		{

 		iConverter = CPlainTextConverter::NewLC();

 		iInputBuffer = new(ELeave) TText[EInputBufferSize];

 		CleanupStack::PushL(iInputBuffer);

 		}

 	else

 		iInputBuffer = NULL;

 	TRAPD(error,TranslateToEofL(aSLBTranslator));

 	if (error == KErrEof)

 		error = KErrNone;

 	if (error == KErrNone)

 		iOutput.CommitL();

 	if (iConverter)

 		{

 		CleanupStack::Pop(iInputBuffer);

 		delete [] iInputBuffer;

 		CleanupStack::PopAndDestroy(iConverter);

 		}

 	User::LeaveIfError(error);

 	}

 void TPlainTextReader::TranslateToEofL(TSLBTransaltor& aSLBTranslator)

 	{

 	while(!Finished())

 		{

 		TText c = ReadAndConvertL();

 		aSLBTranslator.ProcessL(c);

 		}

 	aSLBTranslator.FlushL();

 	}

 TText TPlainTextReader::ReadAndConvertL()

 	{

 	// Read EConversionBufferSize bytes into a conversion buffer (iConversionBuffer).

 	// Using CharConv convert this into unicode and place in a destination buffer (dest).

 	// This may result in some bytes that cannot be converted (remainder) as that

 	// character encoding is truncated.

 	// This remainder is then moved to the begining of the conversion buffer and more

 	// data read in after it, in effect untruncating that last character.

 	// Before this next read takes place the next converted unicode character is returned

 	// until the destination buffer positional pointers reach the end where more data is

 	// required for processing.

 	//  

 	if (iConverter && iInputBuffer)

 		{

 		if (iInputPos >= iInputLength)

 			{

 			/*

 			Attempt to read more foreign characters if there are less than 20,

 			which is the current maximum length of a multibyte character sequence for CHARCONV.

 			Use MStreamBuf::ReadL, which doesn't leave on EOF, rather than RReadStream::ReadL,

 			which does, and doesn't tell you how much was actually read.

 			*/

 			if (iConverter->iConversionBufferLength < 20)

 				iConverter->iConversionBufferLength +=

 					iInput.Source()->ReadL(iConverter->iConversionBuffer + iConverter->iConversionBufferLength,

 										   CPlainTextConverter::EConversionBufferSize - iConverter->iConversionBufferLength);

 			// Create the converter late so we have a sample of foreign text for auto-detection of the encoding.

 			if (!iConverter->iConverter)

 				{

 				TPtrC8 sample(iConverter->iConversionBuffer,iConverter->iConversionBufferLength);

 				iConverter->PrepareToConvertL(*this,&sample);

 				}

 			// Translate from the foreign encoding to Unicode.

 			TPtr dest(iInputBuffer,0,EInputBufferSize);

 			TPtrC8 source(iConverter->iConversionBuffer,iConverter->iConversionBufferLength);

 			int remainder = iConverter->iConverter->ConvertToUnicode(dest,source,iConversionState);

 			if (remainder < 0)

 				User::Leave(KErrCorrupt);

 			// Move the remaining foreign characters if any to the start of the buffer

 			// so that on the next read it can be joined with its truncated part.

 			for (int i = 0, j = iConverter->iConversionBufferLength - remainder; i < remainder; ++i, ++j)

 				iConverter->iConversionBuffer[i] = iConverter->iConversionBuffer[j];

 			iConverter->iConversionBufferLength = remainder;

 			iInputPos = 0;

 			iInputLength = dest.Length();

 			if (iInputLength == 0)

 				User::Leave(KErrEof);

 			}

 		iResult.iInputChars++;

 		return iInputBuffer[iInputPos++];

 		}

 	else

 		return ReadRawCharL();

 	}

 /**

 The method processes the imput characters, writing them to the output, but skipping 

 the picture characters (CEditableText::EPictureCharacter).

 The method is not called directly and should not be called. It implements 

 MOutputChar::OutputCharL(TChar aChar) and is called from TParagraphTextWriter and 

 TLineTextWriter implementations.

 @param aChar Character to be processed.

 */

 void TPlainTextReader::OutputCharL(TText aChar)

 	{

 	switch(aChar)

 		{

 		case CEditableText::EByteOrderMark :

 			// leading byte order marks are ignored

 			if(iResult.iInputChars > 1)

 				{

 				WriteRawCharL(aChar);

 				}

 			break;

 		case CEditableText::EPictureCharacter:

 			//Picture characters are ignored because they would cause ETEXT to panic when it attempted to find

 			//the picture corresponding to the character.

 			break;

 		default:

 			WriteRawCharL(aChar);

 			break;

 		}

 	}