sl@0: /*
sl@0: * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description: 
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: #include "TxtWriter.h"
sl@0: #include <txtetext.h>
sl@0: #include "TXTPLAIN.H"
sl@0: #include "OstTraceDefinitions.h"
sl@0: #ifdef OST_TRACE_COMPILER_IN_USE
sl@0: #include "TxtWriterTraces.h"
sl@0: #endif
sl@0: 
sl@0: 
sl@0: static const TText KLineBreak = 0x0A;//Used by TSLBTransaltor class - 0x0A, 0x0D, {0x0D, 0x0A}
sl@0:                               //character aequences found in the input stream will be translated 
sl@0:                               //to KLineBreak character.
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: // TSLBTransaltor class
sl@0: 
sl@0: /**
sl@0: The method processes the input characters and translates 0x0D, 0x0A and 0x0D 0x0A characters
sl@0: to line breaks. When the next output character is ready, the method calls WriteL() method of
sl@0: the controlled MTextWriter interface (iTextWriter data member) with the output character 
sl@0: as an argument. 
sl@0: Note: Identified line breaks will be translated to 0x0A character. 0x0A character code is very
sl@0:       appropriate for use because all 0x0A, 0x0D or {0x0D, 0x0A} character sequences are filtered
sl@0: 	  from the input stream and it is guaranteed that the output stream can't have any of them.
sl@0: Note: The output character stream should not contain 0x0D character.
sl@0: @param aChar Input character to be processed.
sl@0: */
sl@0: void TSLBTransaltor::ProcessL(TText aChar)
sl@0: 	{
sl@0: 	if(aChar == 0x0A)
sl@0: 		{
sl@0: 		//Output a line break. It does not matter what is the previous character.
sl@0: 		//If it is 0x0D - line break should be the output (0x0D 0x0A). If it is something else - 
sl@0: 		//(i\x0A) again the output is a line break.
sl@0: 		iTextWriter.WriteL(KLineBreak);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if(iPrevChar == 0x0D)
sl@0: 			{
sl@0: 			//Previous character is 0x0D and current character is not 0x0A - then we have to output
sl@0: 			//a line break - the previous character was stored one call before and now has to be 
sl@0: 			//processed, if there is no 0x0A character.
sl@0: 			iTextWriter.WriteL(KLineBreak);
sl@0: 			}
sl@0: 		if(aChar != 0x0D)
sl@0: 			{
sl@0: 			//If current character is 0x0D, then it will be stored for further processing (in 
sl@0: 			//case if the next character is 0x0A). If current character is not 0x0D and not 
sl@0: 			//0x0A - then output it immediately.
sl@0: 			iTextWriter.WriteL(aChar);
sl@0: 			}
sl@0: 		}
sl@0: 	iPrevChar = aChar;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method immediately sends to the output any characters, left for further processing. 
sl@0: The method shoud be called by the TSLBTransaltor's client after the processing of all 
sl@0: input characters.
sl@0: */
sl@0: void TSLBTransaltor::FlushL()
sl@0: 	{
sl@0: 	if(iPrevChar == 0x0D)
sl@0: 		{
sl@0: 		//The last input character is 0x0D and there won't be any more characters, so there is
sl@0: 		//not a chanse to find a matching 0x0A character. Output it as a single line break.
sl@0: 		iTextWriter.WriteL(KLineBreak);
sl@0: 		}
sl@0: 	//iTextWriter has an internal state too. Flush it.
sl@0: 	iTextWriter.FlushL();
sl@0: 	iPrevChar = 0;
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: // TParagraphTextWriter class
sl@0: 
sl@0: /**
sl@0: This method should be called only from TSLBTransaltor implementation. It gets the characters 
sl@0: processed by TSLBTransaltor instance as an input and writes them to the output (using MOutputChar
sl@0: interface - iOutputChar data member), translating line breaks to paragraph delimiters.
sl@0: @param aChar Input character to be processed. It can't be 0x0D, but it could be 0x0A - identified
sl@0:              line break.
sl@0: */
sl@0: void TParagraphTextWriter::WriteL(TText aChar)
sl@0: 	{
sl@0: 	if (aChar == 0x0D)
sl@0: 	    {
sl@0: 	    OstTrace0( TRACE_DUMP, TPARAGRAPHTEXTWRITER_WRITEL, "Invariant" );
sl@0: 	    }
sl@0: 	__ASSERT_DEBUG(aChar != 0x0D, User::Invariant());
sl@0: 	if(aChar == KLineBreak)
sl@0: 		{
sl@0: 		iOutputChar.OutputCharL(CEditableText::EParagraphDelimiter);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iOutputChar.OutputCharL(aChar);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////
sl@0: // TLineTextWriter class
sl@0: 
sl@0: /**
sl@0: This method should be called only from TSLBTransaltor implementation. It gets the characters 
sl@0: processed by TSLBTransaltor instance as an input and writes them to the output (using MOutputChar
sl@0: interface - iOutputChar data member), translating line breaks to paragraph delimiters or spaces.
sl@0: The translation rules are:
sl@0:  - single line break - space;
sl@0:  - double line break - paragraph delimiter;
sl@0: @param aChar Input character to be processed. It can't be 0x0D, but it could be 0x0A - identified
sl@0:              line break.
sl@0: */
sl@0: void TLineTextWriter::WriteL(TText aChar)
sl@0: 	{
sl@0: 	if (aChar == 0x0D)
sl@0: 	    {
sl@0: 	    OstTrace0( TRACE_DUMP, TLINETEXTWRITER_WRITEL, "Invariant" );
sl@0: 	    }
sl@0: 	__ASSERT_DEBUG(aChar != 0x0D, User::Invariant());
sl@0: 	TText prevChar = iPrevChar;
sl@0: 	iPrevChar = aChar;
sl@0: 	if(aChar != KLineBreak)
sl@0: 		{
sl@0: 		if(prevChar == KLineBreak)
sl@0: 			{
sl@0: 			//Current character is not a line break, but the previous one is.
sl@0: 			//Then, it is a single line break - output a space.
sl@0: 			iOutputChar.OutputCharL(' ');
sl@0: 			}
sl@0: 		//Current character is not a line break - then just output it.
sl@0: 		iOutputChar.OutputCharL(aChar);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if(prevChar == KLineBreak)
sl@0: 			{
sl@0: 			//Current character is a line break, previous character is a line break too.
sl@0: 			//Double line break - output a paragraph delimiter.
sl@0: 			//Both characters are consumed, so iPrevChar is set to 0.
sl@0: 			iPrevChar = 0;
sl@0: 			iOutputChar.OutputCharL(CEditableText::EParagraphDelimiter);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method immediately sends to the output any characters, left for further processing. 
sl@0: This method should be called only from TSLBTransaltor implementation.
sl@0: */
sl@0: void TLineTextWriter::FlushL()
sl@0: 	{
sl@0: 	if(iPrevChar == KLineBreak)
sl@0: 		{
sl@0: 		//There is no more input characters and the last input charactes is a line break.
sl@0: 		//Then, treat it as a single line break and output a space.
sl@0: 		iOutputChar.OutputCharL(' ');
sl@0: 		}
sl@0: 	iPrevChar = 0;
sl@0: 	}