/*

* Copyright (c) 1997-2010 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 <e32std.h>

#include <e32base.h>

#include <gdi.h>

#include <conpics.h>

#include <s32file.h>

#include <txtrich.h>

#include <txtfmlyr.h>

#include "TXTMRTSR.H"

#include "../incp/T_PMLPAR.H"

//#include "../spml/T_PMLPAR.CPP"

#include "T_TRAN.h"

LOCAL_D CTestStep *pTestStep = NULL;

#define test(cond)											\

	{														\

	TBool __bb = (cond);									\

	pTestStep->TEST(__bb);									\

	if (!__bb)												\

		{													\

		pTestStep->ERR_PRINTF1(_L("ERROR: Test Failed"));	\

		User::Leave(1);										\

		}													\

	}

#undef INFO_PRINTF1

#undef INFO_PRINTF2

// copy from tefexportconst.h

#define INFO_PRINTF1(p1)        pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1))

#define INFO_PRINTF2(p1, p2)    pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2))

// included in a namespace, to avoid confliction

namespace T_TRAN {

/* this fixes a MSVC link warning */

#ifdef __VC32__

#pragma comment (linker, "/opt:noref") 

#endif

#define UNUSED_VAR(a) a = a

const TInt KTestCleanupStack=0x40;

_LIT(KExportFileName1, "c:\\etext\\t_para.txg");

_LIT(KExportFileName2, "c:\\etext\\t_para2.txg");

void EnsureFileExists(const TDesC& aName)

	{

	RFs fs;

	fs.Connect();

	fs.MkDirAll(aName);

	RFile file;

	file.Create(fs, aName, EFileRead|EFileWrite);

	file.Close();

	fs.Close();

	}

class CContainer : public CBase, public MRichTextStoreResolver

	{

public:

	static CContainer* NewL(TFileName aFileName);

	~CContainer();

	//

	// Mixin

	//

	virtual const CStreamStore& StreamStoreL(TInt aPos)const;

	// Methods

	TStreamId StoreL(CStreamStore& aStore)const;

	void RestoreL(const CStreamStore& aStore,TStreamId aId,MPictureFactory* aFctry);

protected:

	CContainer();

	void ConstructL(TFileName aFileName);

public:

	CRichText* iText;

	const CParaFormatLayer* iGlobalParaFormatLayer;

	const CCharFormatLayer* iGlobalCharFormatLayer;

	};

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RFs TheFs;  // the file server

LOCAL_D RFile TheFile;  // the data file

LOCAL_D CParser* TheParser;

LOCAL_D CContainer* TheContainer;

LOCAL_D CStreamStore* TheDeferredPictureStore;

CContainer* CContainer::NewL(TFileName aFileName)

// Create new container & set its components.

//

	{

	CContainer* self=new(ELeave) CContainer;

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	CleanupStack::Pop();

	return self;

	}

CContainer::CContainer()

	{

	}

void CContainer::ConstructL(TFileName aFileName)

	{

	TheParser=CParser::NewL();

	CleanupStack::PushL(TheParser);

	iText=TheParser->ParseL(aFileName);

	CleanupStack::PopAndDestroy();

	iGlobalParaFormatLayer=iText->GlobalParaFormatLayer();

	iGlobalCharFormatLayer=iText->GlobalCharFormatLayer();

	}

CContainer::~CContainer()

	{

	delete iText;

	delete (CParaFormatLayer*)iGlobalParaFormatLayer;

	delete (CCharFormatLayer*)iGlobalCharFormatLayer;

	}

const CStreamStore& CContainer::StreamStoreL(TInt /*aPos*/)const

// Return the deferred picture store.

// In this instance, the deferred picture store does not vary with document position.

//

	{return *TheDeferredPictureStore;}

TStreamId CContainer::StoreL(CStreamStore& aStore)const

// Store this component

//

	{

	CStoreMap* map=CStoreMap::NewLC(aStore);

	iText->StoreComponentsL(aStore,*map);

	//

	RStoreWriteStream stream(*map);

	TStreamId id=stream.CreateLC(aStore);

	iGlobalParaFormatLayer->ExternalizeL(stream);

	iGlobalCharFormatLayer->ExternalizeL(stream);

	stream<< *iText;

	stream.CommitL();

	//

	map->Reset();

	CleanupStack::PopAndDestroy(2);

	return id;

	}

void CContainer::RestoreL(const CStreamStore& aStore,TStreamId aId,MPictureFactory* aFactory)

// Restore this component

//

	{

	RStoreReadStream stream;

	stream.OpenLC(aStore,aId);

	iGlobalParaFormatLayer=CParaFormatLayer::NewL(stream);

	iGlobalCharFormatLayer=CCharFormatLayer::NewL(stream);

	iText=CRichText::NewL(iGlobalParaFormatLayer,iGlobalCharFormatLayer);

	iText->SetPictureFactory(aFactory,this);

	stream>> *iText;

	//

	CleanupStack::PopAndDestroy();

	//

	iText->RestoreComponentsL(aStore);

	}

/*LOCAL_C void testPictureRestorer(TBool aDeferPictureLoad=ETrue)

// Test Picture persistance.

//

    {

	//

	TheFs.Connect();

	//

	TheStore=CDirectFileStore::ReplaceL(TheFs,_L("c:\\etext\\t_word.doc"),EFileRead|EFileWrite);

	TheDeferredPictureStore=TheStore;

	CleanupStack::PushL(TheStore);

	TheStore->SetTypeL(KDirectFileStoreLayout);

	//

	// Create concrete picture factory.

	MDemPictureFactory* factory=new(ELeave) MDemPictureFactory;

	TheContainer->iText->Reset();

	TheContainer->iText->InsertL(0,_L("Hello Duncan how"));

	TheContainer->iText->SetPictureFactory(factory,TheContainer);

	// Create some pictures.

	CXzePicture* pic1=CXzePicture::NewL('x');

		CleanupStack::PushL(pic1);

	CXzePicture* pic2=CXzePicture::NewL('z');

		CleanupStack::PushL(pic2);

	CXzePicture* pic3=CXzePicture::NewL('e');

		CleanupStack::PushL(pic3);

	//

	// Create the picture headers

	TPictureHeader hdr1;

	TPictureHeader hdr2;

	TPictureHeader hdr3;

	//

	TSize size;

	pic1->GetSizeInTwips(size);

	hdr1.iPictureType=KUidXzePictureType;

	hdr1.iPicture=pic1;

	hdr2.iPictureType=KUidXzePictureType;

	hdr2.iPicture=pic2;

	hdr3.iPictureType=KUidXzePictureType;

	hdr3.iPicture=pic3;

	//

	// Insert the pictures into the rich text

	TBool hasMarkupData=TheContainer->iText->HasMarkupData();

	test(!hasMarkupData);

	TheContainer->iText->CancelInsertCharFormat();

	TheContainer->iText->InsertL(0,hdr1);

	TheContainer->iText->InsertL(5,hdr2);

	TheContainer->iText->InsertL(7,hdr3);

	TheContainer->iText->InsertL(0,CEditableText::EParagraphDelimiter);

	TheContainer->iText->CancelInsertCharFormat();

	TheContainer->iText->InsertL(2,CEditableText::EParagraphDelimiter);

	CleanupStack::Pop(3);

	hasMarkupData=TheContainer->iText->HasMarkupData();

	test(hasMarkupData);

	//

	// High level Store context

	TStreamId id=TheContainer->StoreL(*TheStore);

//

	delete TheContainer->iText;

	delete (CParaFormatLayer*)TheContainer->iGlobalParaFormatLayer;

	delete (CCharFormatLayer*)TheContainer->iGlobalCharFormatLayer;

//

//

//	Now restore the container with rich text

	TheContainer->RestoreL(*TheStore,id,factory);

	if (!aDeferPictureLoad)

		TheContainer->iText->LoadAllPicturesNowL();

	//

	hasMarkupData=TheContainer->iText->HasMarkupData();

	test(hasMarkupData);

	test(TheContainer->iText->ParagraphCount()==3);

	test(TheContainer->iText->DocumentLength()==21);

	TPtrC view;

	TCharFormat format;

	CPicture* picture;

	//

	// TEST THE PICTURE HEADERS, DEPENDING ON WHETHER DEFERRED LOADING IS SET OR NOT

	TPictureHeader hdrA=TheContainer->iText->PictureHeader(1);

	test(hdrA.iPictureType==KUidXzePictureType);

	if (aDeferPictureLoad)

		{

		test(hdrA.iPicture.IsId());

		}

	else

		{

		test(hdrA.iPicture!=NULL);

		test(hdrA.iPicture.IsPtr());

		test(((CXzePicture*)hdrA.iPicture.AsPtr())->iLabel=='x');

		}

	TPictureHeader hdrB=TheContainer->iText->PictureHeader(7);

	test(hdrB.iPictureType==KUidXzePictureType);

	if (aDeferPictureLoad)

		{

		test(hdrB.iPicture.IsId());

		}

	else

		{

		test(hdrB.iPicture!=NULL);

		test(hdrB.iPicture.IsPtr());

		test(((CXzePicture*)hdrB.iPicture.AsPtr())->iLabel=='z');

		}

	TPictureHeader hdrC=TheContainer->iText->PictureHeader(9);

	test(hdrC.iPictureType==KUidXzePictureType);

	if (aDeferPictureLoad)

		{

		test(hdrC.iPicture.IsId());

		}

	else

		{

		test(hdrC.iPicture!=NULL);

		test(hdrC.iPicture.IsPtr());

		test(((CXzePicture*)hdrC.iPicture.AsPtr())->iLabel=='e');

		}

	TPictureHeader hdrD=TheContainer->iText->PictureHeader(0);  // This is not a picture character

	test(hdrD.iPictureType==KNullUid);

	test(hdrD.iPicture==NULL);

	TSize dummySize;

	test(hdrD.iSize==dummySize);

	//

	TheContainer->iText->GetChars(view,format,1);

	test(view[0]==CEditableText::EPictureCharacter);

	picture=TheContainer->iText->PictureHandleL(1);

	test(((CXzePicture*)picture)->iLabel=='x');

	TheContainer->iText->GetChars(view,format,7);

	test(view[0]==CEditableText::EPictureCharacter);

	picture=TheContainer->iText->PictureHandleL(7);

	test(((CXzePicture*)picture)->iLabel=='z');

	TheContainer->iText->GetChars(view,format,9);

	test(view[0]==CEditableText::EPictureCharacter);

	picture=TheContainer->iText->PictureHandleL(9);

	test(((CXzePicture*)picture)->iLabel=='e');

	delete factory;

	CleanupStack::PopAndDestroy();  // TheStore

	TheFs.Close();

    }

LOCAL_C void testPictureRestorer2(TBool aAlwaysFailToLoad=EFalse)

// Test Picture persistance.

//

    {

	//

	TheFs.Connect();

	//

	TheStore=CDirectFileStore::ReplaceL(TheFs,_L("c:\\etext\\t_word1.doc"),EFileRead|EFileWrite);

	TheDeferredPictureStore=TheStore;

	CleanupStack::PushL(TheStore);

	TheStore->SetTypeL(KDirectFileStoreLayout);

	//

	// Create concrete picture factory.

	MDemPictureFactory* factory=new(ELeave) MDemPictureFactory;

	TheContainer->iText->Reset();

	TheContainer->iText->InsertL(0,_L("Hello Duncan how"));

	TheContainer->iText->SetPictureFactory(factory,TheContainer);

	// Create some pictures.

	CXzeDoor* pic1=CXzeDoor::NewL('x',aAlwaysFailToLoad);

		CleanupStack::PushL(pic1);

	CXzeDoor* pic2=CXzeDoor::NewL('z',aAlwaysFailToLoad);

		CleanupStack::PushL(pic2);

	CXzePicture* pic3=CXzePicture::NewL('e');  // Control: will always load.

		CleanupStack::PushL(pic3);

	//

	// Create the picture headers

	TPictureHeader hdr1;

	TPictureHeader hdr2;

	TPictureHeader hdr3;

	//

	TSize size;

	pic1->GetSizeInTwips(size);

	hdr1.iPictureType=KUidXzeDoorType;

	hdr1.iPicture=pic1;

	hdr2.iPictureType=KUidXzeDoorType;

	hdr2.iPicture=pic2;

	hdr3.iPictureType=KUidXzePictureType;

	hdr3.iPicture=pic3;

	//

	// Insert the pictures into the rich text

	TBool hasMarkupData=TheContainer->iText->HasMarkupData();

	test(!hasMarkupData);

	TheContainer->iText->CancelInsertCharFormat();

	TheContainer->iText->InsertL(0,hdr1);

	TheContainer->iText->InsertL(5,hdr2);

	TheContainer->iText->InsertL(7,hdr3);

	TheContainer->iText->InsertL(0,CEditableText::EParagraphDelimiter);

	TheContainer->iText->CancelInsertCharFormat();

	TheContainer->iText->InsertL(2,CEditableText::EParagraphDelimiter);

	CleanupStack::Pop(3);  // pic1,2,3 - ownership transferred to rich text

	hasMarkupData=TheContainer->iText->HasMarkupData();

	test(hasMarkupData);

	//

	// High level Store context - all pictures currently in memory

	TStreamId id=TheContainer->StoreL(*TheStore);

//

	delete TheContainer->iText;

	delete (CParaFormatLayer*)TheContainer->iGlobalParaFormatLayer;

	delete (CCharFormatLayer*)TheContainer->iGlobalCharFormatLayer;

//

//

//	Now restore the container with rich text

	TheContainer->RestoreL(*TheStore,id,factory);

//

//

//  Now store the stuff again

	TInt error=TheContainer->iText->LoadAllPicturesNowL();

	if (error==KErrNotFound)

		INFO_PRINTF1(_L("   SIMULATION: Some picture data has been removed as no app could be found."));

//	if (aAlwaysFailToLoad)

//		test(error==KErrNotFound);

//	else

//		test(error==KErrNone);

	id=KNullStreamId;

	TRAP(error,

	id=TheContainer->StoreL(*TheStore));

	test(error==KErrNone);

//

// ...and restore it to check what we have got.

	delete TheContainer->iText;

	delete (CParaFormatLayer*)TheContainer->iGlobalParaFormatLayer;

	delete (CCharFormatLayer*)TheContainer->iGlobalCharFormatLayer;

    TheContainer->RestoreL(*TheStore,id,factory);

	TInt pictureCount=TheContainer->iText->PictureCount();

	if (aAlwaysFailToLoad)

		test(pictureCount==1);

	else

		test(pictureCount==3);

//

	delete factory;

	CleanupStack::PopAndDestroy();  // TheStore

	TheFs.Close();

    }*/

LOCAL_C void CompareRichTextL(CRichText *aDoc1,CRichText *aDoc2)

//

	{

	INFO_PRINTF1(_L("Comparing Documents"));

	TInt length;

	TInt num1,num2;

 	TInt ii=0,len1,len2,pos1,pos2,oldPos;

	INFO_PRINTF1(_L("Document Length"));

	length=aDoc1->LdDocumentLength();

	num2=aDoc2->LdDocumentLength();

	test(length==num2);

	INFO_PRINTF1(_L("Paragraph Count"));

	num1=aDoc1->ParagraphCount();

	num2=aDoc2->ParagraphCount();

	test(num1==num2);

	INFO_PRINTF1(_L("Paragraph Lengths"));

	pos1=-1;

	oldPos=-2;

	while (pos1>oldPos)

		{

		oldPos=pos1;

		pos1=aDoc1->CharPosOfParagraph(len1,ii);

		pos2=aDoc2->CharPosOfParagraph(len2,ii);

		test(len1==len2);

		test(pos1==pos2);

		ii++;

		}

	INFO_PRINTF1(_L("Word Count"));

	num1=aDoc1->WordCount();

	num2=aDoc2->WordCount();

	test(num1==num2);

	INFO_PRINTF1(_L("Characters"));

	TCharFormat format1,format2;

	TPtrC chars1,chars2;

	len1=1;

	ii=0;

	while (ii<=length)

		{

		aDoc1->GetChars(chars1,format1,ii);

		aDoc2->GetChars(chars2,format2,ii);

		len1=Min(chars1.Length(),chars2.Length());

		test(chars1.Left(len1)==chars2.Left(len1));

		test(format1.IsEqual(format2));

		test(format2.IsEqual(format1));

		ii+=len1;

		}

	}

LOCAL_C  void GoL()

// Run the tests

//

	{

	CParaFormatLayer* pLayer=CParaFormatLayer::NewL();

	CCharFormatLayer* cLayer=CCharFormatLayer::NewL();

	CRichText *document=CRichText::NewL(pLayer,cLayer);

	TInt err;

	INFO_PRINTF1(_L("Document with single Paragraph"));

	INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-TTEXT-LEGACY-T_TRAN-0001 "));

	{	

	TheContainer=CContainer::NewL(_L("z:\\test\\app-framework\\etext\\t_para.pml"));

	INFO_PRINTF1(_L("Exporting a file by Para"));

	TFileName exportFile=KExportFileName1();

	EnsureFileExists(exportFile);

	TRAP(err,TheContainer->iText->ExportAsTextL(exportFile,CPlainText::EOrganiseByParagraph,0));

	test(err==KErrNone);

	INFO_PRINTF1(_L("Importing a file by Para"));

	document->Reset();

	TInt charsImported=document->ImportTextFileL(0,exportFile,CPlainText::EOrganiseByParagraph);

	test(charsImported>0);

	INFO_PRINTF1(_L("Comparing Result"));

	TRAP(err,CompareRichTextL(TheContainer->iText,document));

 	test(err==KErrNone);

	delete TheContainer;

	}

	{

	TheContainer=CContainer::NewL(_L("z:\\test\\app-framework\\etext\\t_para.pml"));

	INFO_PRINTF1(_L("Exporting and Importing a file by Line"));

	INFO_PRINTF1(_L("Line Lengths 25,30,...,95"));

	TFileName exportFile=KExportFileName1();

	TInt ii;

	for(ii=25;ii<100;ii+=5)

		{

		INFO_PRINTF1(_L("With next line length"));

		EnsureFileExists(exportFile);

		TRAP(err,TheContainer->iText->ExportAsTextL(exportFile,CPlainText::EOrganiseByLine,ii));

		test(err==KErrNone);

		document->Reset();

		TInt charsImported=document->ImportTextFileL(0,exportFile,CPlainText::EOrganiseByLine);

		test(charsImported>0);

		TRAP(err,CompareRichTextL(TheContainer->iText,document));

 		test(err==KErrNone);

		}

	delete TheContainer;

	}

	INFO_PRINTF1(_L("Document with two Paragraphs"));

	{	

	TheContainer=CContainer::NewL(_L("z:\\test\\app-framework\\etext\\t_para2.pml"));

	INFO_PRINTF1(_L("Exporting a file by Para"));

	TFileName exportFile=KExportFileName2();

	EnsureFileExists(exportFile);

	TRAP(err,TheContainer->iText->ExportAsTextL(exportFile,CPlainText::EOrganiseByParagraph,0));

	test(err==KErrNone);

	INFO_PRINTF1(_L("Importing a file by Para"));

	document->Reset();

	TInt charsImported=document->ImportTextFileL(0,exportFile,CPlainText::EOrganiseByParagraph);

	test(charsImported>0);

	INFO_PRINTF1(_L("Comparing Result"));

	TRAP(err,CompareRichTextL(TheContainer->iText,document));

 	test(err==KErrNone);

	delete TheContainer;

	}

	{

	TheContainer=CContainer::NewL(_L("z:\\test\\app-framework\\etext\\t_para.pml"));

	INFO_PRINTF1(_L("Exporting and Importing a file by Line"));

	INFO_PRINTF1(_L("Line Lengths 30,40,...,100"));

	TFileName exportFile=KExportFileName1();

	TInt ii;

	for(ii=30;ii<105;ii+=10)

		{

		INFO_PRINTF1(_L("With next line length"));

		EnsureFileExists(exportFile);

		TRAP(err,TheContainer->iText->ExportAsTextL(exportFile,CPlainText::EOrganiseByLine,ii));

		test(err==KErrNone);

		document->Reset();

		TInt charsImported=document->ImportTextFileL(0,exportFile,CPlainText::EOrganiseByLine);

		test(charsImported>0);

		TRAP(err,CompareRichTextL(TheContainer->iText,document));

 		test(err==KErrNone);

		}

	delete TheContainer;

	}

	delete document;

	delete cLayer;

	delete pLayer;

	}

LOCAL_C void setupCleanup()

//

// Initialise the cleanup stack.

//

    {

	TheTrapCleanup=CTrapCleanup::New();

	TRAPD(r,\

		{\

		for (TInt i=KTestCleanupStack;i>0;i--)\

			CleanupStack::PushL((TAny*)1);\

		test(r==KErrNone);\

		CleanupStack::Pop(KTestCleanupStack);\

		});

	}

LOCAL_C void DeleteDataFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

			if(err != KErrNone) 

				{

				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone) 

				{

				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	}

}

CT_TRAN::CT_TRAN()

    {

    SetTestStepName(KTestStep_T_TRAN);

    pTestStep = this;

    }

TVerdict CT_TRAN::doTestStepL()

    {

    SetTestStepResult(EFail);

    INFO_PRINTF1(_L("Testing Picture Restorer mechanism"));

    __UHEAP_MARK;

    T_TRAN::setupCleanup();

    TRAPD(r, T_TRAN::GoL());

    delete T_TRAN::TheTrapCleanup;

    __UHEAP_MARKEND;

    T_TRAN::DeleteDataFile(T_TRAN::KExportFileName1);     //deletion of data files must be before call to End() - DEF047652

    T_TRAN::DeleteDataFile(T_TRAN::KExportFileName2); 

    if (r == KErrNone)

        {

        SetTestStepResult(EPass);

        }

    return TestStepResult();

    }