/*

 * 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;

 	__UHEAP_MARK;

 	{

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

 		{

 		__UHEAP_SETFAIL(RHeap::EDeterministic,ii);

 		__UHEAP_MARK;

 		appUi=new(ELeave) CWordAppUi;

 		appUi->SetDocument(this);

 		TInt err=KErrNone;

 		if (appUi)

 			{

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

 			delete appUi;

 			appUi=NULL;

 			}

 		__UHEAP_MARKEND;

 		User::Heap().Check();

 		if (err==KErrNone)

 			break;

 		}

 	__UHEAP_MARKEND;

 	__UHEAP_RESET;

 	User::Heap().Check();

 	}

 #endif

     return(new(ELeave) CWordAppUi);

 	}