// 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 the License "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 <s32stor.h>

#include <fbs.h>

#include "APGDOOR.H"

#include "APGICNFL.H"

#include "APGCLI.H"

#include "APACLN.H"

#include "APGSTD.H"

#include "APGPRIV.H"

#include "APFDEF.H"

#include "../apparc/TRACE.H"

const TUid KUidApaDoorStateStream={0x1000012a}; // build invariant

const TInt KHugeGranularity=4096; // 4k granularity for the door's host buffer

// default icon size only used if door was created by a model door, set to glass, but does not support glass

#define KDefaultIconSizeInTwips TSize(500,500)

///////////////////////////////////////////

// CApaDoor

///////////////////////////////////////////

EXPORT_C CApaDoor* CApaDoor::NewLC(RFs& aFs, CApaDocument& aDoc,const TSize& aDefaultIconSizeInTwips)

/** Creates a new wrapper for the specified embedded document and places a

pointer to it onto the cleanup stack.

The door is of the specified size. The wrapper takes ownership of the document; 

if creation of the wrapper fails, the document object is destroyed.

@param aFs A file server session.

@param aDoc The document for which the door is to be created.

@param aDefaultIconSizeInTwips The size of the door in twips.

@return  The new embedded document wrapper object. */

	{

	CApaDoor* self=new CApaDoor(aFs, aDoc,aDefaultIconSizeInTwips);

	if (!self)

		{

		__ASSERT_DEBUG(aDoc.Process(), Panic(EDPanicNoProcess));

		aDoc.Process()->DestroyDocument(&aDoc);

		User::LeaveNoMemory();

		}

	CleanupStack::PushL(self);

	self->ConstructL(); //lint !e613 Possible use of null pointer - Lint is wrong, see User::LeaveNoMemory() above

	return self;

	}

EXPORT_C CApaDoor* CApaDoor::NewL(RFs& aFs, CApaDocument& aDoc,const TSize& aDefaultIconSizeInTwips)

/** Creates a new wrapper for the specified embedded document.

The door is of the specified size. The wrapper takes ownership of the document; 

if creation of the wrapper fails, the document object is destroyed.

@param aFs A file server session.

@param aDoc The document for which the door is to be created.

@param aDefaultIconSizeInTwips The size of the door in twips.

@return  The new embedded document wrapper object. */

	{

	CApaDoor* self = CApaDoor::NewLC(aFs, aDoc,aDefaultIconSizeInTwips);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CApaDoor* CApaDoor::NewL(RFs& aFs, const CStreamStore& aStore,TStreamId aStreamId,CApaProcess& aProcess)

// Creates a door and restores it

// Should only be called by the TApaPictureFactory

//

	{

	CApaDoor* self=new(ELeave) CApaDoor(aFs, aProcess);

	CleanupStack::PushL(self);

	self->RestoreL(aStore,aStreamId);

	CleanupStack::Pop();

	return self;

	}

CApaDoor::CApaDoor(RFs& aFs, CApaDocument& aDoc,const TSize& aDefaultIconSizeInTwips)

	:iFs(aFs),

	iApaProcess(aDoc.Process()),

	iApaDoc(&aDoc),

	iIconSizeInTwips(aDefaultIconSizeInTwips)

	{__DECLARE_NAME(_S("CApaDoor"));}

CApaDoor::CApaDoor(RFs& aFs, CApaProcess& aProcess)

	:iFs(aFs),

	iApaProcess(&aProcess)

	{__DECLARE_NAME(_S("CApaDoor"));}

EXPORT_C CApaDoor::~CApaDoor()

/** Destructor.

Frees all resources owned by the object, prior to its destruction. In particular, 

it destroys the document, removing all references to it from the application 

process. */

	{

	delete iPicture;

	if (iApaDoc)

		iApaProcess->DestroyDocument(iApaDoc); // removes it from the process and deletes it

	delete iAppCaption;

	delete iStore;

	delete iStoreHost;

	iApaProcess = NULL;

	iApaDoc = NULL;

	}

void CApaDoor::ConstructL()

	{

	__SHOW_TRACE(_L("Starting CApaDoor::ConstructL"));

	__APA_PROFILE_START(3);

	__ASSERT_ALWAYS(iApaDoc,Panic(EPanicNoDocumentOnConstruction));

	//

	// check that the doc supports embedding

	TApaAppCapabilityBuf buf;

	__ASSERT_DEBUG(iApaDoc->Application(), Panic(EDPanicNoApplication));

	iApaDoc->Application()->Capability(buf);

	if (buf().iEmbeddability==TApaAppCapability::ENotEmbeddable)

		User::Leave(KErrNotSupported);

	//

	__SHOW_TRACE(_L("...doc is embeddable"));

	//

	// set up the icon

	SetFormatToIconL();

	//

	__PROFILE_END(3);

	}

TStreamId CApaDoor::StoreL(CStreamStore& aTargetStore)const

/** Stores the embedded document in the specified store as an embedded store.

This function saves the format of the door. It also stores the document, if 

the document exists in memory, otherwise, it simply copies the stream containing 

the embedded document into the specified store.

@param aStore The store into which the embedded document is to be stored.

@return The stream ID of the head stream for the embedded document. This stream 

contains the stream dictionary through which the embedded document and its 

door can be restored. */

	{

	__SHOW_TRACE(_L("Starting CApaDoor::StoreL"));

	__APA_PROFILE_START(4);

	// create stream dictionary

	CStreamDictionary* streamDic = CStreamDictionary::NewLC();

	//

	// stream out door's state

	ExternalizeBaseStreamL(aTargetStore,*streamDic);

	ExternalizeStateStreamL(aTargetStore,*streamDic);

	//

	// store the doc if it exists, otherwise copy the persistent data directly

	TStreamId id;

	RStoreWriteStream stream;

	if (iApaDoc)

		{

		// create an embedded store in a new write stream

		id = stream.CreateL(aTargetStore);

		CEmbeddedStore* target=CEmbeddedStore::NewLC(stream); // takes ownership of stream

		streamDic->AssignL(KUidApaDoorDocStream,id);

		StoreDocL(*target);

		// close the new embedded store

		target->CommitL();

		CleanupStack::PopAndDestroy(); // target

		}

	else if (iStore)

		{

		RStoreWriteStream trg;

		id = trg.CreateLC(aTargetStore);

		CopyStoreL(*iStore,trg);

		CleanupStack::PopAndDestroy(); // trg

		streamDic->AssignL(KUidApaDoorDocStream,id);

		}

	else 

		Panic(EPanicNoDocOrStoreWhenStoring); // impossible situation

	//

	// store the stream dictionary and return its stream id

	id = stream.CreateLC(aTargetStore);

	stream<< *streamDic;

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

	//

	// tidy up

	CleanupStack::PopAndDestroy(); // streamDic

	__PROFILE_END(4);

	return id;

	}

void CApaDoor::CopyStoreL(const CEmbeddedStore& aSourceStore,RWriteStream& aTargetStream)

// static method

// copies an embedded store containing a doc to aTargetStream

//

	{

	__SHOW_TRACE(_L("Starting CApaDoor::CopyStoreL"));

	// read the contents of aSourceStore's rootstream (so I can write it out in a mo')

	CStreamDictionary* root=ReadStreamDictionaryLC(aSourceStore,aSourceStore.Root());

	//

	// copy the source store directly

	MStreamBuf* host=aSourceStore.Host();

	__ASSERT_DEBUG(host, Panic(EDPanicNoHostForStore));

	TStreamPos pos=aSourceStore.Position(aSourceStore.Root());

	host->SeekL(host->ERead,EStreamBeginning);

	RReadStream stream(host);

	aTargetStream.WriteL(stream,pos.Offset());

	//

	// write the root stream

	aTargetStream<< *root;

	aTargetStream.CommitL();

	CleanupStack::PopAndDestroy(); // root

	}

EXPORT_C void CApaDoor::RestoreL(const CStreamStore& aSourceStore,TStreamId aStreamId)

/** Restores the embedded document from the specified store.

The format of the door is set to iconic if the embedded document is password 

protected.

@param aStore The store from which the embedded document is to be restored. 

@param aHeadStreamId The stream ID of the head stream for the embedded document. 

This stream contains the stream dictionary through which the embedded document 

and its door can be restored. */

	{

	__SHOW_TRACE(_L("Starting CApaDoor::RestoreL"));

	__APA_PROFILE_START(5);

	__ASSERT_DEBUG(iApaProcess,Panic(EDPanicNoProcess));

	//

	if (iApaDoc)

		{

		iApaProcess->DestroyDocument(iApaDoc);

		iApaDoc = NULL;

		}

	delete iStore;

	delete iStoreHost;

	iStore=NULL;

	iStoreHost = NULL;

	//

	// internalize the streamDic from the headstream

	CStreamDictionary* streamDic=ReadStreamDictionaryLC(aSourceStore,aStreamId);

	//

	// internalize the door's state

	__APA_PROFILE_START(13);

	TSize currentSize=InternalizeBaseStreamL(aSourceStore,*streamDic);

	InternalizeStateStreamL(aSourceStore,*streamDic,currentSize);

	__APA_PROFILE_END(13);

	//

	// internalize the embedded store

	__APA_PROFILE_START(14);

	RStoreReadStream src;

	src.OpenL(aSourceStore,streamDic->At(KUidApaDoorDocStream));

	iStore = CEmbeddedStore::FromL(src);

	CleanupStack::PopAndDestroy(); // streamDic

	streamDic = NULL;

	__APA_PROFILE_END(14);

	//

	// internalize the doc's stream dict

	streamDic = ReadStreamDictionaryLC(*iStore,iStore->Root());

	//

	// set the door's format 

	if (iFormat==EIconic || (streamDic->At(KUidSecurityStream)!=KNullStreamId))

		// iconify automatically if a password is required for access

		SetFormatToIconL();

	else

		{

		TRAPD(ret, SetFormatToGlassL() );

		if (ret==KErrNone)

			{

			__ASSERT_DEBUG(iPicture, Panic(EDPanicNoPictureOnDrawing));

			iPicture->SetSizeInTwips(currentSize);

			}

		else if (ret!=KErrNoMemory)

			// problem loading app/doc - just iconify it for now...

			SetFormatToIconL();

		else

			User::Leave(ret);

		}	

	CleanupStack::PopAndDestroy(); // streamDic

	__PROFILE_END(5);

	}

void CApaDoor::StoreDocL(CPersistentStore& aTargetStore)const

// stores the doc if it's in memory, otherwise panics!

// aStore should be protected before calling this method

//

	{

	__SHOW_TRACE(_L("Starting CApaDoor::StoreDocL"));

	__ASSERT_ALWAYS(iApaDoc,Panic(EPanicNoDocumentOnStore)); // the doc must be in memory to be stored

	//

	// create a stream dic

	CStreamDictionary* streamDic=CStreamDictionary::NewLC();

	// store the doc

	iApaDoc->StoreL(aTargetStore,*streamDic);

	// write store's root stream

	CApaProcess::WriteRootStreamL(aTargetStore,*streamDic,*iApaDoc->Application());

	// tidy up

	CleanupStack::PopAndDestroy(); // streamDic

	}

void CApaDoor::RestoreDocL(const CPersistentStore& aSourceStore)

// restores the document from the embedded store

// leaves with KErrNotFound if the app dll cant be located

//

	{

	__SHOW_TRACE(_L("Starting CApaDoor::RestoreDocL"));

	__ASSERT_ALWAYS(!iApaDoc,Panic(EPanicDocAlreadyExists));

	//

	// read the stream dic from the doc's root stream

	CStreamDictionary* streamDic=ReadStreamDictionaryLC(aSourceStore,aSourceStore.Root());

	//

	// read the app id from the store

	TApaAppIdentifier appId = CApaProcess::ReadAppIdentifierL(aSourceStore,*streamDic);

	//

	__ASSERT_DEBUG(iApaProcess,Panic(EDPanicNoProcess));

	// if the app exists find it, load it and create a doc, else leave if the correct app cannot be found

	CApaDocument* doc = // create an unrestored doc and adds it to the process list

	iApaProcess->AddNewDocumentL(appId.iAppUid);

	TApaDocCleanupItem cleanup(iApaProcess,doc);

	CleanupStack::PushL(cleanup);

	doc->RestoreL(aSourceStore,*streamDic); // restores the doc

	iApaDoc = doc;

	CleanupStack::Pop(); // doc

	CleanupStack::PopAndDestroy(); // streamDic

	}

CStreamDictionary* CApaDoor::ReadStreamDictionaryLC(const CStreamStore& aSourceStore,TStreamId aStreamId)

// static method

//

	{

	__APA_PROFILE_START(12);

	// read the stream dic from the doc's root stream

	CStreamDictionary* streamDic=CStreamDictionary::NewLC();

	RStoreReadStream stream;

	stream.OpenLC(aSourceStore,aStreamId);

	stream>> *streamDic;

	CleanupStack::PopAndDestroy(); // root

	__APA_PROFILE_END(12);

	return streamDic;

	}

void CApaDoor::ExternalizeL(RWriteStream& /*aStream*/)const

	{

	Panic(EPanicMethodNotSupported);

	}

void CApaDoor::ExternalizeStateStreamL(CStreamStore& aStore,CStreamDictionary& aStreamDict)const

	{

	__SHOW_TRACE(_L("Starting CApaDoor::ExternalizeStateStreamL"));

	__ASSERT_ALWAYS(iAppCaption,Panic(EPanicNoCaption));

	__ASSERT_ALWAYS(iPicture,Panic(EPanicNoPictureInDoor));

	RStoreWriteStream stream;

	TStreamId id=stream.CreateLC(aStore);

	//

	stream<< *iAppCaption;

	TSize size;

	if (iFormat==EIconic || iFormat==ETemporarilyIconic)

		GetSizeInTwips(size);

	else 

		size = iIconSizeInTwips;

	stream<< size;

	//

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

	aStreamDict.AssignL(KUidApaDoorStateStream,id);

	}

void CApaDoor::InternalizeStateStreamL(const CStreamStore& aStore,const CStreamDictionary& aStreamDict,TSize aDefaultIconSize)

	{

	__SHOW_TRACE(_L("Starting CApaDoor::InternalizeStateStreamL"));

	TStreamId id=aStreamDict.At(KUidApaDoorStateStream);

	if (id!=KNullStreamId)

		{

		RStoreReadStream stream;

		stream.OpenLC(aStore,id);

		TApaAppCaption caption;

		stream>> caption;

		delete iAppCaption;

		iAppCaption = NULL;

		iAppCaption = caption.AllocL();

		stream>> iIconSizeInTwips;

		CleanupStack::PopAndDestroy(); // stream

		}

	else

		{// use default settings

		delete iAppCaption;

		iAppCaption = NULL;

		iAppCaption = HBufC::NewL(0);

		if (iFormat==EIconic)

			iIconSizeInTwips = aDefaultIconSize;

		else

			iIconSizeInTwips = KDefaultIconSizeInTwips;

		}

	}

void CApaDoor::DetachFromStoreL(TDetach aDegree)

/** Detaches the door from its store, restoring any unrestored elements of the picture, 

if necessary.

@param aDegree Degree to which picture is detached.

@see CApaDocument::DetachFromStoreL() */

	{

	__SHOW_TRACE(_L("Starting CApaDoor::DetachFromStoreL"));

	if (iApaDoc)

		{

		iApaDoc->DetachFromStoreL(aDegree);

		if (!iStoreHost)

			{

			delete iStore;

			iStore = NULL;

			}

		}

	else if (!iStoreHost)

		{

		if (aDegree==EDetachDraw)

			{

			delete iStore;

			iStore = NULL;

			// now all I can do is draw as I am, any attempt to change me will result in a panic

			}

		else

			{

			__ASSERT_ALWAYS(iStore,Panic(EPanicNoStoreOnDetach));

			// instantiate the mem buffer, and a stream to write to it

			CBufSeg* bufSeg = CBufSeg::NewL(KHugeGranularity);

			CleanupStack::PushL(bufSeg);

			HBufBuf* buf=HBufBuf::NewL(*bufSeg,0);

			RWriteStream writeStream(buf);

			writeStream.PushL();

			// write the store to the mem buffer

			CopyStoreL(*iStore,writeStream);

			CleanupStack::Pop(2); // bufSeg,writeStream

			//

			// set iStoreHost as host for the embedded store

			MStreamBuf* host=iStore->Host();

			__ASSERT_ALWAYS(host!=NULL,Panic(EDPanicNoHostForStore));

			iStore->Detach();

			host->Release(); //lint !e613 Suppress possible use of null pointer

			iStore->Reattach(buf);

			iStoreHost = bufSeg;

			}

		}

	}

EXPORT_C CApaDocument* CApaDoor::DocumentL(TBool aCheckPassword)

// leaves with KErrNotFound if the doc needs to be restored but the app dll cannot be found

//

/** Returns a pointer to the embedded document represented by this wrapper.

If necessary, the document is restored from its embedded store.

Note that if the wrapper does not have a reference to the embedded document 

store, then the function raises a APGRFX 13 panic. Constructing this wrapper 

through a TApaPictureFactory or storing the embedded document through CApaDoor::StoreL() 

ensures that this wrapper has a reference to the embedded document store.

@param aCheckPassword If ETrue, any password is checked before returning a 

pointer to the document. If EFalse, the password is not checked.

@return A pointer to the embedded document.

@see TApaPictureFactory

@see CApaDoor::StoreL()

@see CApaDocument::ValidatePasswordL() */

	{

	__SHOW_TRACE(_L("Starting CApaDoor::DocumentL"));

	//

	if (!iApaDoc)

		{

		__ASSERT_ALWAYS(iStore,Panic(EPanicNoStoreOnRestore));

		RestoreDocL(*iStore);

		}

	else if (aCheckPassword)

		iApaDoc->ValidatePasswordL();

	//

	return iApaDoc;

	}

EXPORT_C void CApaDoor::SetFormatToTemporaryIconL(TBool aEnabled)

// if the door is currently iconic do nothing

// if the door is glass switch it's format to iconic, but ensure that when externalized the format will be persisted as glass

//

/** Switches the format of the door between temporarily iconic and glass.

If the door is iconic, then the function does nothing.

@param aEnabled If ETrue and the format is currently glass, then the format 

switches to temporarily iconic; this is the default. If EFalse and the format 

is currently temporarily iconic, then the format switches to glass. */

	{

	__SHOW_TRACE(_L("Starting CApaDoor::SetFormatToTemporaryIconL"));

	if (aEnabled && iFormat==EGlassDoor) 

		{

		TSize glassSize;

		GetSizeInTwips(glassSize);

		SetFormatToIconL();

		iFormat = ETemporarilyIconic;

		iIconSizeInTwips = glassSize; //abuse it!

		}

	else if (!aEnabled && iFormat==ETemporarilyIconic)

		SetFormatToGlassL();

	}

#ifdef __VC32__

#pragma optimize("g", off) // Disable due to problem with MSVC

#endif

EXPORT_C void CApaDoor::SetFormatToIconL()

/** Sets the format of the door to iconic.