/*

* 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 <s32std.h>

#include <s32stor.h>

#include <s32file.h>

#include <f32file.h>

#include <gdi.h>

#include <txtrich.h>

#include "txtmrtsr.h"

#include <frmprint.h>

#include <prnsetup.h>

#include <basched.h>

#include <coemain.h>

#include <apparc.h>

#include <apgdoor.h>

#include <eikproc.h>

#include <techview/eikpword.h>

#include <techview/eikon.rsg>

#include <eikfutil.h>

#include <techview/eikdialg.h>

#include <eikenv.h>

#include "WNGMODEL.H"

#include "WPDOC.H"

#include "WPAPPUI.H"

#include "WPMAIN.H"

#include "WPPANIC.H"

#include "wpresources.h"

#include <word.rsg>

#include "WORD.HRH"

//#define ALLOC_TESTING

//

// CWordDocument

//

const TUid KUidWordAppUiStream={268436035};

CWordDocument* CWordDocument::NewL(CEikApplication& aApp)

// Return a handle to a new instance of this class.

//

	{

#if defined(ALLOC_TESTING)

	// reserve some space on the cleanup stack

	{for (TInt ii=0;ii<1000;++ii)

		CleanupStack::PushL(&ii);}

	CleanupStack::Pop(1000);

	//

	__UHEAP_MARK;

	{

	CWordDocument* self=NULL;

	for (TInt ii=2;;++ii)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic,ii);

		__UHEAP_MARK;

		TInt err=KErrNone;

		self=new(ELeave) CWordDocument(aApp);

		if (self)

			{

			TRAP(err,self->ConstructL());

			delete self;

			self=NULL;

			}

		__UHEAP_MARKEND;

		User::Heap().Check();

		if (err==KErrNone)

			break;

		}

	__UHEAP_MARKEND;

	__UHEAP_RESET;

	User::Heap().Check();

	}

#endif

	CWordDocument* self=new(ELeave) CWordDocument(aApp);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CWordDocument::ConstructL()

// Complete initialisation

//

	{

	CreateModelL();

	ConstructPrintL();

	iUiData=new(ELeave) TWordUiData;

	}

CWordDocument::~CWordDocument()

	{

	delete iModel;

	delete iPrint;

	delete iUiData;

	}

void CWordDocument::CreateModelL()

	{iModel=CWordModel::NewL(this,this);}

void CWordDocument::ConstructPrintL()

// Print initialisation

//

	{

	CCoeEnv* coeEnv=CCoeEnv::Static();

	CWordModel& model=*Model();

	CPrintSetup& printSetup=*model.PrintSetup();

	printSetup.CreatePrinterDeviceL(KUidPrinterDevice,coeEnv->FsSession());

	iPrint=CTextPageRegionPrinter::NewL(model.Text(),printSetup.PrinterDevice());

	//

	TPageMargins margins;									 

	margins.iMargins.iLeft=1440;

	margins.iMargins.iRight=1440;			

	margins.iMargins.iTop=1440;		   

	margins.iMargins.iBottom=1440;

	margins.iHeaderOffset=720;

	margins.iFooterOffset=720;

	TPageSpec pageSpec;

	pageSpec.iPortraitPageSize=TSize(11906,16838);	   // A4 !!	

	printSetup.iPageMarginsInTwips=margins;

  	printSetup.PrinterDevice()->SelectPageSpecInTwips(pageSpec);	   // A4 !!

	}

void CWordDocument::NewDocumentL()

// Builds a new main (container) document, creating content from a standard file.

// If a leave occurs whilst loading the standard document, current document

// content will not be lost.

//

	{ 

	TFileName templateFileName;

	TWordFilePath::GetNormalTemplateFolderName(templateFileName);

	TFindFile* ff = new(ELeave) TFindFile(Process()->FsSession());

	CleanupStack::PushL(ff);

	TFileName* tempFileName = new(ELeave) TFileName();

	CleanupStack::PushL(tempFileName);

	CCoeEnv* coeEnv = CCoeEnv::Static();

	coeEnv->ReadResource(*tempFileName, R_WORD_NORMAL_TEMPLATE_FILE_NAME);

	templateFileName.Append(*tempFileName);

	// look for a normal template

	templateFileName[0] = 'Y';

	TParsePtrC tParse(templateFileName);

	TInt error = ff->FindByDir(templateFileName,tParse.DriveAndPath());

	if(error)

		{

		// no normal template, search ROM for blank

		TWordFilePath::GetNormalTemplateFolderName(templateFileName);

		coeEnv->ReadResource(*tempFileName, R_WORD_BLANK_TEMPLATE_FILE_NAME);

		templateFileName.Append(*tempFileName);

		templateFileName[0] = 'Z';

		TParsePtr blankParse(templateFileName);

		error = ff->FindByDir(blankParse.NameAndExt(),blankParse.DriveAndPath());

		}

	CleanupStack::PopAndDestroy(); // tempFileName

	if(error!=KErrNone)

		Panic(EDefaultTemplateNotPresent);

	templateFileName = ff->File();

	CleanupStack::PopAndDestroy(); // ff

	DoNewDocumentL(templateFileName);

	if (iAppUi)

		WordAppUi().NotifyNewTextL();  // edwin must know of new text for focus loss etc...

	}

CFileStore* CWordDocument::DoNewDocumentL(const TDesC& aStandardDocument,TKeepStoreOpen aKeepStoreOpen/*=EKeepFalse*/)

// Open and restore the specified valid document.

// The store that is opened over the file for restoration may be kept open, or destroyed, depending on

// the value of aKeepStoreOpen.

//

	{

	CFileStore* store=NULL;

	CStreamDictionary* dictionary=CApaProcess::ReadRootStreamLC(Process()->FsSession(),store,aStandardDocument,EFileShareExclusive|EFileRead);  // takes ownership of store

	CleanupStack::PushL(store);

	iNewDocument = ETrue;

	RestoreL(*store,*dictionary);

	iNewDocument = EFalse;

	iModel->Text()->DetachFromStoreL(CPicture::EDetachFull);

	if (aKeepStoreOpen==EKeepTrue)

		CleanupStack::Pop();  // store

	else

		CleanupStack::PopAndDestroy();  // store

	CleanupStack::PopAndDestroy();  // dictionary

	return (aKeepStoreOpen==EKeepTrue)

		? store

		: NULL;

	}

void CWordDocument::LocateTemplateL(const TDes& aFullFileName) const

// Verify that the template file selected by the user is still present

//

	{

	TFindFile ff(Process()->FsSession());

	TParsePtrC tParse(aFullFileName);

	User::LeaveIfError(ff.FindByDir(aFullFileName,tParse.DriveAndPath()));

	VerifyDocumentTypeL(aFullFileName);

	}

void CWordDocument::VerifyDocumentTypeL(const TFileName& aFileName)const

// Verify the document of the specified name is indeed of the

// same type as this document object.

//

	{

	TEntry entry;

	User::LeaveIfError(Process()->FsSession().Entry(aFileName,entry));

	if (entry.MostDerivedUid()!=Application()->AppDllUid())

		User::Leave(KErrCorrupt);

	}

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

// In this case the store does not vary with document position.

//

	{return *iEditStore;}

void CWordDocument::DetachFromStoreL(CPicture::TDetach aDegree)

// Propogate the detachFromStore to all picture container components.

//

	{

	iModel->Text()->DetachFromStoreL(aDegree);

	CRichText* text=iModel->PrintSetup()->Header()->Text();

	if (text)

		text->DetachFromStoreL(aDegree);

	text=iModel->PrintSetup()->Footer()->Text();

	if (text)

		text->DetachFromStoreL(aDegree);

	iEditStore=NULL;

	}

void CWordDocument::StoreUiDataL(CStreamStore& aStore,CStreamDictionary& aStreamDic)const

// Write any Ui data

//

	{

	if (iAppUi)

		WordAppUi().GetUiData(*iUiData);

	RStoreWriteStream stream;

	TStreamId id=stream.CreateLC(aStore);

	stream <<*iUiData;

	stream.CommitL();

	CleanupStack::PopAndDestroy();  // stream

	aStreamDic.AssignL(KUidWordAppUiStream,id);

	}

void CWordDocument::StoreL(CStreamStore& aStore,CStreamDictionary& aStreamDic)const

// Write this object network.

//

	{

	if (iAppUi)

		CEikonEnv::Static()->BusyMsgL(R_EIK_TBUF_SAVING_FILE,KFileBusyInitialDelayInMicroSeconds);

	StoreUiDataL(aStore,aStreamDic);

	iModel->StoreL(aStore, aStreamDic, 0);

	if (iAppUi)

		CEikonEnv::Static()->BusyMsgCancel();

	}

void CWordDocument::RestoreUiDataL(const CStreamStore& aStore,const CStreamDictionary& aStreamDic)

// Restore any ui data for future use

//

	{

	TStreamId id=aStreamDic.At(KUidWordAppUiStream);

	if (id==KNullStreamId)

		iUiData->Reset();

	else

		{

		RStoreReadStream stream;

		stream.OpenLC(aStore,id);

		stream>> *iUiData;

		CleanupStack::PopAndDestroy();  // stream

		}

	}

void CWordDocument::RestoreL(const CStreamStore& aStore,const CStreamDictionary& aStreamDic)

// Restore this document.

// All model restoration is done here, to save having a temporary model member data,

// implementing a rollback robust model restore.

//

	{

	CEikonEnv* eikonEnv=CEikonEnv::Static();

	if (iAppUi && !iNewDocument)

		eikonEnv->BusyMsgL(R_EIK_TBUF_OPENING_FILE,KFileBusyInitialDelayInMicroSeconds);

	else if (iAppUi && iNewDocument)

		eikonEnv->BusyMsgL(R_WORD_FILE_CREATE_FILE,KFileBusyInitialDelayInMicroSeconds);

	//

	CWordModel* tempModel=CWordModel::NewL(this,this);

	CleanupStack::PushL(tempModel);

	//

	CStreamStore* oldStore=iEditStore;

	iEditStore=CONST_CAST(CStreamStore*,&aStore);

	//

	tempModel->Text()->SetPictureFactory(&iPictureFactory,this);  // rich text callbacks

	TRAPD(ret,

		tempModel->RestoreL(aStore,aStreamDic,0,this,this,eikonEnv->PictureFactory()));  // print setup field callbacks

	if (ret!=KErrNone)

		{

		iEditStore=oldStore;

		User::Leave(ret);

		}

	delete iModel;

	iModel=tempModel;  // document takes over ownership

	CleanupStack::Pop();  // tempModel

	SetChanged(EFalse);  // this is a brand new document - it cannot yet have been changed.

	TRAP(ret,

	RestoreUiDataL(aStore,aStreamDic));

		if (ret!=KErrNone)

			iUiData->Reset();  // do not propogate.  We can handle this.

	//

	if (iAppUi)

		{

		WordAppUi().SetUiData();

//		CEikonEnv::Static()->BusyMsgCancel();

		}

	}

TInt CWordDocument::UpdateFieldFileName(TPtr& aValueText)const

// Set aValueText with the current document filename only.

// (No path or extension).

//

	{

	TParsePtrC parser(Process()->MainDocFileName());

	TPtrC pp=parser.NameAndExt();

	if (pp.Length()>aValueText.MaxLength())

		return pp.Length();

	aValueText=pp;

	return 0;

	}

TInt CWordDocument::UpdateFieldNumPages()const

// Return the number of pages currently in this document.

// Precondition: pagination of the document has already occured.

//

	{return iModel->PageTable()->Count();}

void CWordDocument::DoFileNewL(const TFileName& aNewFilename, const TFileName& aTemplateFileName)

// Create an initialised document instance with the specified name,

// and initialise a new file store to store the document in.

// (A new document is not created, *this* instance is re-used).

//

	{

	//

	// Create the file store for the new document

	LocateTemplateL(aTemplateFileName);

	User::LeaveIfError(EikFileUtils::CopyFile(aTemplateFileName,aNewFilename));

	CCoeEnv* coeEnv=CCoeEnv::Static();

	User::LeaveIfError(coeEnv->FsSession().SetAtt(aNewFilename,KEntryAttNormal,KEntryAttReadOnly));

	// turn read-only file attribute if set, just to be safe.

	//

	CFileStore* store=DoNewDocumentL(aNewFilename,EKeepTrue);

	__ASSERT_DEBUG(store,Panic(ENewFileNullStore));

	//

	SetMainStoreAndMainDocFileName(store,aNewFilename);

	SetChanged(ETrue);

	TUint appFileMode=AppFileMode();

	appFileMode|=EFileWrite;

	SetAppFileMode(appFileMode);

	WordAppUi().SetReadOnly((TBool)!(appFileMode&EFileWrite));

	}

void CWordDocument::SetMainStoreAndMainDocFileName(CFileStore* aMainStore,const TDesC& aMainDocFileName)

	{

	CEikProcess& process=REINTERPRET_CAST(CEikProcess&,*Process());

	delete process.MainStore();  // remove the [original] store

	process.SetMainStore(aMainStore);  // set the new file store as the main one.

	process.SetMainDocFileName(aMainDocFileName);

	}

void CWordDocument::DoFileOpenL(const TFileName& aFileName,TUint aFileMode)

// Open the Word document specified by aFileName.

//

	{

	VerifyDocumentTypeL(aFileName);

	RFs session=Process()->FsSession();

	GetFileOpenModeL(aFileMode,aFileName,session);

//

	CFileStore* store=NULL;

	CStreamDictionary* dic=CApaProcess::ReadRootStreamLC(session,store,aFileName,EFileShareExclusive|aFileMode);

	CleanupStack::PushL(store);

	RestoreL(*store,*dic);

	CleanupStack::Pop();  // store

	CleanupStack::PopAndDestroy();  // dictionary

	//

	SetMainStoreAndMainDocFileName(store,aFileName);

	SetAppFileMode(aFileMode);

	WordAppUi().SetReadOnly((TBool)!(aFileMode&EFileWrite));

	}

void CWordDocument::GetFileOpenModeL(TUint& aFileMode,const TDesC& aFilename,RFs& aSession)

// Attempt to open the specified file in the specified mode.

// If this fails because write access was requested on a read-only file,

// the file is opened read-only.

// Any other error (leave) is propogated.

// aFileMode is set to the mode that the file was successfully opened in.

//

	{

	CFileStore* store=NULL;

	TRAPD(ret,

	store=CFileStore::OpenL(aSession,aFilename,aFileMode));

	if (ret==KErrAccessDenied && aFileMode&EFileWrite)

		{

		ret=KErrNone;

		aFileMode&=~EFileWrite;

		store=CFileStore::OpenL(aSession,aFilename,aFileMode);

		}

	//

	User::LeaveIfError(ret);

	__ASSERT_DEBUG(ret==KErrNone && store,Panic(EFileOpenIntegrityError));

	delete store;

	}

void CWordDocument::DoFileSaveToCurrentL()

	{

	SaveL();	  

	}

void CWordDocument::DoFileSaveToNewL(const TFileName& aNewFileName)

	{

	((CEikProcess*)Process())->SaveToDirectFileStoreL(this,&aNewFileName); // writes root stream

	SetAppFileMode(EFileWrite);

	}

void CWordDocument::DoFileSaveToNewNoSwitchL(const TFileName& aNewFileName)

// Save the current file to a new file, but don't open the new file

	{

	// From CEikProcess::SaveToDirectFileStoreL but without the close iMainDoc at the end

	//

	CApaProcess* proc = Process();

	RFs& fsSession=proc->FsSession();

	CDirectFileStore* store;

	store = CDirectFileStore::CreateLC(fsSession,aNewFileName,EFileWrite);

	store->SetTypeL(REINTERPRET_CAST(CEikProcess*,proc)->MainStore()->Type());

	CStreamDictionary* streamDic=CStreamDictionary::NewL();

	CleanupStack::PushL(streamDic);

	proc->MainDocument()->StoreL(*store,*streamDic);

	// write root stream

	proc->WriteRootStreamL(*store,*streamDic,*(this->Application()));

	CleanupStack::PopAndDestroy(); // streamDic

	// close the new store

	store->CommitL();

	CleanupStack::PopAndDestroy(); // store

	}

void CWordDocument::DoFileRevertL()

	{

	CStreamDictionary* streamDic=CStreamDictionary::NewL();

	CleanupStack::PushL(streamDic);

	CFileStore* mainStore=REINTERPRET_CAST(CEikProcess*,Process())->MainStore();

	RStoreReadStream root;

	root.OpenLC(*mainStore,mainStore->Root());

	root>> *streamDic;

	root.Close();

	CleanupStack::PopAndDestroy(); // root

	RestoreL(*mainStore,*streamDic);

	CleanupStack::PopAndDestroy(); // streamDic

	}

//

// CWordApplication

//

TUid CWordApplication::AppDllUid() const

	{

	return KUidWordAppValue;

	}

CApaDocument* CWordApplication::CreateDocumentL()

	{return CWordDocument::NewL(*this);}

CEikAppUi* CWordDocument::CreateAppUiL()

	{

#if defined(ALLOC_TESTING)

	// reserve some space on the cleanup stack

	{for (TInt ii=0;ii<1000;++ii)

		CleanupStack::PushL(&ii);}

	CleanupStack::Pop(1000);

	// construct the appUi before the setfail loop so that cached resources

	// do not cause alloc failure

	CWordAppUi* appUi=NULL;

	appUi=new(ELeave) CWordAppUi;

	appUi->SetDocument(this);

	appUi->ConstructL();

	delete appUi;

	appUi=NULL;