// Copyright (c) 2004-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:

// GMXMLCOMPOSE.CPP

// @file

// This file contains the declaration of the generic CMDXMLComposer class 

// which is responsible for creating an XML file

// from a given DOM structure.

// 

//

#include <f32file.h>

#include <utf.h>

#include <gmxmlconstants.h>

#include <gmxmlnode.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include <gmxmlcomposer.h>

#include <gmxmlentityconverter.h>

#include <gmxmltext.h>

#include <gmxmlprocessinginstruction.h>

#include <gmxmlcomment.h>

#include <gmxmlcdatasection.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include "gmxmldummydtd.h"

#endif

_LIT(KXmlQuotation, """);

//

// CMDXMLComposer					//

//

CMDXMLComposer::CMDXMLComposer(MMDXMLComposerObserver* aComposerObserver) : CActive(EPriorityNormal)

//

// Constructor

//

	{

	iComposerObserver = aComposerObserver;

	iOutputProlog = ETrue;

	CActiveScheduler::Add(this);

	}

CMDXMLComposer::CMDXMLComposer(MMDXMLComposerObserver* aComposerObserver, TBool aOutputProlog) : CActive(EPriorityNormal),

	iOutputProlog(aOutputProlog)

//

// Constructor

//

	{

	iComposerObserver = aComposerObserver;

	CActiveScheduler::Add(this);

	}

//==================================================================================

EXPORT_C CMDXMLComposer::~CMDXMLComposer()

	{

	Cancel();

	delete iEntityConverter;

	delete iCharconv;

	iXMLFile.Close();

	}

//==================================================================================

void CMDXMLComposer::BaseConstructL()

	{

	iCharconv = CCnvCharacterSetConverter::NewL();

	iCharconv->SetDowngradeForExoticLineTerminatingCharacters(

		CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed);

	}

//==================================================================================

EXPORT_C CMDXMLComposer* CMDXMLComposer::NewL(MMDXMLComposerObserver* aComposerObserver)

//

// Two phase static factory function constructor

// @param aEntityStrings the string table which lists the entity references and conversion

// @return Created CMDXMLComposer

// @leave can Leave due to OOM

//

	{

	CMDXMLComposer* self = NewLC(aComposerObserver);

	CleanupStack::Pop(self);

	return self;

	}

//==================================================================================

EXPORT_C CMDXMLComposer* CMDXMLComposer::NewL(MMDXMLComposerObserver* aComposerObserver, TBool aOutputProlog)

//

// Two phase static factory function constructor

// @param aEntityStrings the string table which lists the entity references and conversion

// @param aOutputProlog Whether the Doctype and Version tags should be output.  This is

// provided for MMS conformance.

// @return Created CMDXMLComposer

// @leave can Leave due to OOM

//

	{

	CMDXMLComposer* self = NewLC(aComposerObserver, aOutputProlog);

	CleanupStack::Pop(self);

	return self;

	}

//==================================================================================

EXPORT_C CMDXMLComposer* CMDXMLComposer::NewLC(MMDXMLComposerObserver* aComposerObserver)

//

// Two phase static factory function constructor

// @param aEntityStrings the string table which lists the entity references and conversion

// @return Created CMDXMLComposer

// @leave can Leave due to OOM

//

	{

	CMDXMLComposer* self = new (ELeave) CMDXMLComposer(aComposerObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//==================================================================================

EXPORT_C CMDXMLComposer* CMDXMLComposer::NewLC(MMDXMLComposerObserver* aComposerObserver, TBool aOutputProlog)

//

// Two phase static factory function constructor

// @param aEntityStrings the string table which lists the entity references and conversion

// @param aOutputProlog Whether the Doctype and Version tags should be output.  This is

// provided for MMS conformance.

// @return Created CMDXMLComposer

// @leave can Leave due to OOM

//

	{

	CMDXMLComposer* self = new (ELeave) CMDXMLComposer(aComposerObserver, aOutputProlog);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//==================================================================================

void CMDXMLComposer::ConstructL()

//

// Second stage constructor

// @param aEntityStrings the string table which lists the entity references and conversion

//

	{

	BaseConstructL();

	CMDXMLEntityConverter* entityConverter = new(ELeave) CMDXMLEntityConverter();

	SetEntityConverter(entityConverter);

	}

//==================================================================================

void CMDXMLComposer::InitialiseCompose(CMDXMLDocument* aDocument, TXMLFileType aFileType)

	{

	Cancel();

	iError = KErrNone;

	iSeverity = EXMLNone;

	iOutputBuffer.Zero();

	iXMLDoc = aDocument;

	iFileType = aFileType;

	iOnlyCalculatingSize = EFalse;

	iSizeTally = 0;

	}

EXPORT_C TInt CMDXMLComposer::ComposeFile(RFs aRFs, const TDesC& aFileToCompose, CMDXMLDocument* aDocument, TXMLFileType aFileType)

/** Starts file composition.

This function can not be called if there is an outstanding size calculation or compose

operation in progress. If it is necessary to run two asynchronous operations in parallel

then two instances of the CMDXMLComposer are needed.

@param aRFS File system to use

@param aFileToCompose Name of file to create

@param aDocument The document object to compose to the file

@return KERRNone if successful

**/

	{

	InitialiseCompose(aDocument, aFileType);

	iRFs = aRFs;

	TInt error = KErrNone;

	if(iXMLDoc == NULL)

		{

		error = KErrNotSupported;

		}

	else

		{

		switch(iFileType)

			{

			case EAscii:

				{

				error = iXMLFile.Replace(aRFs, aFileToCompose, EFileWrite | EFileStream);

				break;

				}

			case EUnicode:

				error = iXMLFile.Replace(aRFs, aFileToCompose, EFileWrite | EFileStream);

				if(error == KErrNone)

					{

					// append Unicode File identifier to start of output text

					iOutputBuffer.Append(CEditableText::EByteOrderMark);

					}

				break;

			case EUtf8:

				{

				error = iXMLFile.Replace(aRFs, aFileToCompose, EFileWrite | EFileStream);

				break;

				}

			default:

				error = KErrNotSupported;

				break;

			}

		}

	if(error == KErrNone)

		{

		SetActive();

		TRequestStatus* s=&iStatus;

		User::RequestComplete(s, KErrNone);

		}

	else

		{

		SetError(error, EXMLFatal);

		}

	return error;

	}

/** Starts file composition to an open file handle.

This function must not be called when file sizing is in progress. If it is necessary to calulate

the size and generate the XML simultaneously then two instances of the composer should be used,

one for sizing and one for composition.

@param aFileHandleToCompose An open file handle to write to. Ownership of the file handle is passed even if an error occurs.

@param aDocument The document object to compose to the file.

@param aFileType Type of the output file.

@return KErrNone if successful.

*/

EXPORT_C TInt CMDXMLComposer::ComposeFile(RFile& aFileHandleToCompose, CMDXMLDocument* aDocument, TXMLFileType aFileType)

	{

	InitialiseCompose(aDocument, aFileType);

	iXMLFile = aFileHandleToCompose;

	TInt error = KErrNone;

	if(iXMLDoc == NULL)

		{

		error = KErrNotSupported;

		}

	else

		{

		switch(iFileType)

			{

			case EUnicode:

				{

				// append Unicode File identifier to start of output text

				iOutputBuffer.Append(CEditableText::EByteOrderMark);

				}

			case EAscii:

			case EUtf8:

				break;

			default:

				error = KErrNotSupported;

				break;

			}

		}

	if(error == KErrNone)

		{

		iStatus = KRequestPending;

		SetActive();

		TRequestStatus* s=&iStatus;

		User::RequestComplete(s, KErrNone);

		}

	else

		{

		iXMLFile.Close();

		SetError(error, EXMLFatal);

		}

	return error;

	}

//==================================================================================

/** Starts calculating the size of the XML output without actually writing it to the file.

This process is asyncronous, the size value is only updated when ComposeFileComplete

is called on the MMDXMLComposerObserver passed in in the NewL.

This function can not be called if there is an outstanding size calculation or compose

operation in progress. If it is necessary to run two asynchronous operations in parallel

then two instances of CMDXMLComposer are needed.

@param aSize Will be set to the size of the XML document when composition has completed.

@param aDocument The document object to size

@param aFileType Type of the output file, required because it will affect the size of the XML

@return KErrNone if successful */

EXPORT_C TInt CMDXMLComposer::CalculateFileSize(TInt& aSize, CMDXMLDocument* aDocument, TXMLFileType aFileType)

	{

	Cancel();

	iError = KErrNone;

	iSeverity = EXMLNone;

	iOutputBuffer.Zero();

	iXMLDoc = aDocument;

	iFileType = aFileType;

	TInt error = KErrNone;

	if (iFileType == EUnicode)

		{

		// The size tally must be incremented by two characters because the unicode byte marker

		// gets added in the ComposeFile function that does not get called when we are calculating

		// the size.

		iSizeTally = 2;

		}

	else

		{

		iSizeTally = 0;

		}

	iSize = &aSize;

	iOnlyCalculatingSize = ETrue;

	if(iXMLDoc == NULL)

		{

		error = KErrNotSupported;

		}

	if(error == KErrNone)

		{

		SetActive();

		TRequestStatus* s=&iStatus;

		User::RequestComplete(s, KErrNone);

		}

	else

		{

		SetError(error, EXMLFatal);

		}

	return error;

	}

//==================================================================================

EXPORT_C TInt CMDXMLComposer::Error() const

	{

	return iError;

	}

//==================================================================================

EXPORT_C TXMLErrorCodeSeverity CMDXMLComposer::ErrorSeverity() const

	{

	return iSeverity;

	}

//==================================================================================

EXPORT_C CMDXMLEntityConverter* CMDXMLComposer::EntityConverter() const

	{

	return iEntityConverter;

	}

//==================================================================================

TInt CMDXMLComposer::OutputCommentL(const TDesC& aComment)

//

// Output a comment

// @param aComment the comment text to output

// @return KERRNone if successful, otherwise a file writing error.

//

	{

	TInt error = KErrNone;

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KNewLine);

		}

#ifdef _DEBUG

	for(TInt loopIndex = 0; loopIndex < iIndentationLevel; loopIndex++)

		{

		if(iSeverity != EXMLFatal)

			{

			error = WriteFileL(KTab);

			}

		}

#endif

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLStartComment);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(aComment);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLEndComment);

		}

	return error;

	}

//==================================================================================

TInt CMDXMLComposer::OutputProcessingInstructionL(const TDesC& aInstruction)

//

// Output a Processing Instruction

// @param aInstruction the Processing Instruction text to output

// @return KERRNone if successful, otherwise a file writing error.

//

	{

	TInt error = KErrNone;

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KNewLine);

		}

#ifdef _DEBUG

	for(TInt loopIndex = 0; loopIndex < iIndentationLevel; loopIndex++)

		{

		if(iSeverity != EXMLFatal)

			{

			error = WriteFileL(KTab);

			}

		}

#endif

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLStartProcessingInstruction);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(aInstruction);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLEndProcessingInstruction);

		}

	return error;

	}

//==================================================================================

TInt CMDXMLComposer::OutputCDataSectionL(const TDesC& aCDataSection)

//

// Output a CDataSection

// @param aCDataSection the data section text to output

// @return KERRNone if successful, otherwise a file writing error.

//

	{

	TInt error = KErrNone;

#ifdef _DEBUG

	for(TInt loopIndex = 0; loopIndex < iIndentationLevel; loopIndex++)

		{

		if(iSeverity != EXMLFatal)

			{

			error = WriteFileL(KTab);

			}

		}

#endif

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLStartCDataSection);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(aCDataSection);

		}

	if(iSeverity != EXMLFatal)

		{

		error = WriteFileL(KXMLEndCDataSection);

		}

	return error;

	}

//==================================================================================

//Defect fix for INC036136- Enable the use of custom entity converters in GMXML

EXPORT_C TInt CMDXMLComposer::OutputDataL(const TDesC& aData)

//

// Output raw data

// it's only intended to be used from within a custom entity converter as

// it relies on a Composer sesssion already being in progress

// @param the data to be output

// @return KERRNone if successful, otherwise a file writing error.

//

	{

	TInt error = KErrNone;

	if(iSeverity != EXMLFatal)

		{

		if(aData.Find(KQuotation) != KErrNotFound)

			{