/*

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

 #include <e32base.h>

 #include <s32strm.h>

 #include <s32stor.h>

 #include "FLDDEF.H"

 #include "FLDSET.H"

 #include "FLDARRAY.H"

 #include "FLDSTD.H"

 EXPORT_C TFieldMapExternalizer::TFieldMapExternalizer(const CStoreMap& aMap)

 	: iMap(&aMap)

 	{}

 EXPORT_C void TFieldMapExternalizer::ExternalizeL(const TStreamRef& aRef,RWriteStream& aStream) const

 // Write the stream id bound to aRef to aStream. If not bound, write KNullStreamId

 //

 	{

 	TSwizzleC<TAny> swizzle=aRef;

 	aStream<<iMap->At(swizzle);

 	}

 EXPORT_C TStreamId CTextFieldSet::StoreL(CStreamStore& aStore)const

 // Save the fields and the fieldSet in their own streams

 // Encapsulates the storing of its components.

 //

 	{

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

 	StoreFieldsL(aStore,*map);  // binds id's to swizzles

 //

 	// create custom externalizer over the map

 	TFieldMapExternalizer fMap(*map);

 	RStoreWriteStream stream(fMap);

 	TStreamId id=stream.CreateLC(aStore);

 	stream<< *this;

 	stream.CommitL();

 	CleanupStack::PopAndDestroy();  // stream

 //

 	map->Reset();

 	CleanupStack::PopAndDestroy();  // map

 	return id;

 	}

 EXPORT_C void CTextFieldSet::StoreFieldsL(CStreamStore& aStore,CStoreMap& aMap)const

 // Stores all fields in the set

 //

 	{StoreFieldsL(aStore,aMap,iFieldArray);}

 void CTextFieldSet::StoreFieldsL(CStreamStore& aStore,CStoreMap& aMap,CArrayFixSeg<TTextFieldEntry>* aArray)const

 // Stores all fields contained in the set provided

 //

 	{

 	__TEST_INVARIANT;

 	for (TInt i=0 ; i<(aArray->Count()-1) ; i++)

 		{

 		TStreamId id=(*aArray)[i].iFieldHeader.iField->StoreL(aStore);

 		if (id!=KNullStreamId)

 			aMap.BindL((*aArray)[i].iFieldHeader.iField,id);

 		}

 	}

 EXPORT_C void CTextFieldSet::ExternalizeL(RWriteStream& aStream)const

 	{

 	__TEST_INVARIANT;

 	ExternalizeL(aStream,iFieldArray);

 	}

 void CTextFieldSet::ExternalizeL(RWriteStream& aStream,CArrayFixSeg<TTextFieldEntry>* aArray)const

 	{

 	TInt numFieldEntries = aArray->Count();

 	aStream.WriteInt32L(numFieldEntries);

 	// write out fields

 	for (TInt i=0 ; i<numFieldEntries-1 ; i++)

 		aStream<< (*aArray)[i];

 	// write out last entry in array: the bit after the last field

 	aStream.WriteInt32L((*aArray)[numFieldEntries-1].iPreFieldLen);

 	}

 EXPORT_C void CTextFieldSet::RestoreL(const CStreamStore& aFieldStore,TStreamId aStreamId)

 	{

 	// reset the array and stream into it

 	Reset();

 	DoRestoreL(aFieldStore,aStreamId);

 	}

 EXPORT_C void CTextFieldSet::RestoreFieldsL(const CStreamStore& aFieldStore)

 	{

 	DoRestoreFieldsL(iFieldArray,aFieldStore); // restore the fields individually from their own streams

 	}

 void CTextFieldSet::DoRestoreL(const CStreamStore& aFieldStore,TStreamId aStreamId)

 // Restores a field set and its associated fields from the store provded.

 // 

 	{

 	__ASSERT_ALWAYS(iFieldArray->Count()==1,Panic(EArrayNotEmptyOnRestore)); // array must be empty

 	__ASSERT_ALWAYS((*iFieldArray)[0].iPreFieldLen==0,Panic(EArrayNotEmptyOnRestore));

 	// retrieve the headstream from the store

 	RStoreReadStream stream;

 	stream.OpenLC(aFieldStore,aStreamId);

 	// restore the set, then the individual fields

 	stream>> *this;  // internalize the field set (the headers)

 	CleanupStack::PopAndDestroy(); // stream

 	DoRestoreFieldsL(iFieldArray,aFieldStore); // restore the fields individually from their own streams

 	}

 EXPORT_C void CTextFieldSet::InternalizeL(RReadStream& aStream)

 	{

 	InternalizeL(iFieldArray,aStream);

 	__TEST_INVARIANT;

 	}

 void CTextFieldSet::InternalizeL(CArrayFixSeg<TTextFieldEntry>* aArray,RReadStream& aStream)

 	{// assume the array is empty

 	TInt numFieldEntries = aStream.ReadInt32L();

 	// read in the fields

 	TTextFieldEntry entry;

 	for (TInt i=0 ; i<numFieldEntries-1 ; i++)

 		{

 		aStream>> entry;

 		InsertEntryL(i,entry,aArray); // insert new entry

 		}

 	// read in the last entry: the bit after the last field. This will not contain a field

 	(*aArray)[numFieldEntries-1].iPreFieldLen = aStream.ReadInt32L();

 	}

 void CTextFieldSet::DoRestoreFieldsL(CArrayFixSeg<TTextFieldEntry>* aArray,const CStreamStore& aFieldStore,TInt aStartIndex)

 // This fn is called after all FieldHeaders have been internalized - the Swizzles hold the stream id's.

 // One by one the fields are created (with the factory) and then have their settings streamed in from the store.

 // If no factory exists all fields are converted to text.

 //

 	{

 	TInt ii=aArray->Count()-2;  // -2 because we skip the last (empty) entry

 	while (ii>=aStartIndex)

 		{

 		if ((*aArray)[ii].iFieldHeader.iField.IsId()) 

 			{// restore the field only if it isn't the very last (dummy) entry

 			if (iFieldFactory==NULL)

 				// no factory - convert the field to text

 				DeleteFieldEntry(aArray,ii);

 			else

 				{

 				TStreamId id = (*aArray)[ii].iFieldHeader.iField.AsId();

 				(*aArray)[ii].iFieldHeader.iField = iFieldFactory->NewFieldL((*aArray)[ii].iFieldHeader.iFieldType);

 				if ((*aArray)[ii].iFieldHeader.iField!=NULL)

 					(*aArray)[ii].iFieldHeader.iField->RestoreL(aFieldStore,id);

 				else

 					DeleteFieldEntry(aArray,ii); // handle "field type not recognised" by converting field to text

 				}

 			}

 		ii--;

 		}

 	}

 /***************************************** cut & paste *******************************************/

 EXPORT_C TStreamId CTextFieldSet::CopyToStoreL(CStreamStore& aStore,TInt aPos,TInt aLength)const

 // Copy any fields in the selected region to the specified store, returning the id of the head-stream.

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));

 	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));

 	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

 	// Create a store map and store the fields themselves

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

 	CopyComponentsL(aStore,*map,aPos,aLength);

 	// Create a head-stream in which to store the field entries and do so

 	RStoreWriteStream stream(*map);

 	TStreamId id=stream.CreateLC(aStore);

 	CopyToStreamL(stream,aPos,aLength);

 	// tidy up

 	stream.CommitL();

 	map->Reset();

 	CleanupStack::PopAndDestroy(2); // map, stream

 	return id;

 	}

 EXPORT_C void CTextFieldSet::CopyComponentsL(CStreamStore& aStore,CStoreMap& aMap,TInt aPos,TInt aLength)const

 // Stores all fields in the set

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));

 	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));

 	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

 	// Create an array of the fields to be cut/copied

 	CArrayFixSeg<TTextFieldEntry>* tempArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);

 	CleanupStack::PushL(tempArray);

 	CopyToArrayL(tempArray,aPos,aLength);

 	// stream the required fields in their own streams

 	StoreFieldsL(aStore,aMap,tempArray);

 	CleanupStack::PopAndDestroy(); // tempArray

 	}

 EXPORT_C void CTextFieldSet::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength)const

 // Stores all fields in the set

 //

 	{

 	__TEST_INVARIANT;

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));

 	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));

 	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

 	// Create an array of the fields to be cut/copied

 	CArrayFixSeg<TTextFieldEntry>* tempArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);

 	CleanupStack::PushL(tempArray);

 	CopyToArrayL(tempArray,aPos,aLength);

 	// stream the field entries in the temp array

 	ExternalizeL(aStream,tempArray);

 	CleanupStack::PopAndDestroy(); // tempArray

 	}

 void CTextFieldSet::CopyToArrayL(CArrayFixSeg<TTextFieldEntry>* aArray,TInt aPos,TInt aLength)const

 	{

 	TInt index; TInt offset;

 	if (InField(aPos,index,offset))

 		offset += (*iFieldArray)[index].iPreFieldLen; // make offset relative to start of entry

 	// split first entry in range

 	TTextFieldEntry entry = SplitEntry(index,offset,aLength);

 	index++;

 	TInt charsCopied=EntryLen(entry);

 	// split second if neccessary

 	if ((!entry.iFieldHeader.iField)&&(charsCopied<aLength))

 		{

 		TInt preFieldLen = entry.iPreFieldLen;

 		entry = SplitEntry(index,0,aLength-preFieldLen);

 		entry.iPreFieldLen += preFieldLen;

 		charsCopied = EntryLen(entry);

 		index++;

 		}

 	((CTextFieldSet*)this)->AppendEntryL(entry,aArray); // append the first entry to the storage array

 	// write out all whole entries

 	while (charsCopied<aLength)

 		{

 		if ((charsCopied+EntryLen(index))<=aLength)

 			((CTextFieldSet*)this)->AppendEntryL((*iFieldArray)[index],aArray); 

 		charsCopied += EntryLen(index);

 		index++;

 		}

 	// split last entry if neccessary

 	if (charsCopied>aLength)

 		{// The last entry needs to be split

 		// first get back to the beginning of the entry

 		index--;

 		charsCopied -= EntryLen(index);

 		entry = SplitEntry(index,0,aLength-charsCopied); // split up the last entry as required

 		((CTextFieldSet*)this)->AppendEntryL(entry,aArray); // append the last entry to the storage array

 		}

 	// add an empty last entry if neccessary

 	TInt numFieldEntries = aArray->Count();

 	if (((*aArray)[numFieldEntries-1].iFieldHeader.iField) || ((*aArray)[numFieldEntries-1].iFieldValueLen!=0))

 		{

 		entry.iPreFieldLen = 0;

 		entry.iFieldValueLen = 0;

 		entry.iFieldHeader.iFieldType = KNullUid;

 		entry.iFieldHeader.iField = NULL;

 		((CTextFieldSet*)this)->AppendEntryL(entry,aArray);

 		numFieldEntries++;

 		}

 	}

 EXPORT_C void CTextFieldSet::PasteFromStoreL(const CStreamStore& aFieldStore,TStreamId aStreamId,TInt aPos,TInt aMaxLen)

 // Paste from aStore into the document at insert position aPos.

 // Optionally the pasted text can be clipped to a maximum length aMaxLen.

 //

 	{

 	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));

 	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutOfRange));

 	// retrieve the headstream from the store

 	RStoreReadStream stream;

 	stream.OpenLC(aFieldStore,aStreamId);

 	// restore the set...

 	PasteFromStreamL(stream,aPos,aMaxLen); // internalize the field set (the headers)

 	CleanupStack::PopAndDestroy(); // stream

 	// ...then the individual fields

 	PasteComponentsL(aFieldStore,aPos); // restore the fields individually from their own streams

 	}

 EXPORT_C void CTextFieldSet::PasteFromStreamL(RReadStream& aStream,TInt aPos,TInt aMaxLen)

 // streams the field entries into a temporary array, which is returned. 

 // PasteComponents() must be called after this to actually carry out the paste...

 	{

 	// create a temporary array to stream in to, inserting the first entry

 	CArrayFixSeg<TTextFieldEntry>* tempFieldArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);

 	CleanupStack::PushL(tempFieldArray);

 	AddInitialFieldEntryL(tempFieldArray,0);

 	// internalize the field entries

 	InternalizeL(tempFieldArray,aStream);

 	// trim off any entries that lie beyond aMaxLength

 	if (aMaxLen!=ENoPasteLimit)

 		{// if aMaxLen is not ENoPasteLimit discard the excess fields

 		__ASSERT_ALWAYS(aMaxLen>=0,Panic(ELengthOutOfRange));

 		//

 		TInt length=0;

 		TInt i=0;

 		for (i=0 ; (length<aMaxLen)&&(i<tempFieldArray->Count()) ; i++)

 			length += EntryLen((*tempFieldArray)[i]);

 		if (aMaxLen==0)

 			{// make first entry zero len, delete all others

 			i++;

 			(*tempFieldArray)[i-1].iPreFieldLen = 0;

 			}

 		else if (length>aMaxLen)

 			// truncate the last field in range

 			(*tempFieldArray)[i-1].iPreFieldLen += (*tempFieldArray)[i-1].iFieldValueLen-(length-aMaxLen);

 		else if ((length==aMaxLen) && ((*tempFieldArray)[i-1].iFieldHeader.iField!=NULL))

 			{// if the terminating entry has a field add a zero length entry, the mandatory last entry

 			i++;

 			(*tempFieldArray)[i-1].iPreFieldLen = 0;

 			}

 		// ensure the last entry is of the correct format

 		(*tempFieldArray)[i-1].iFieldValueLen = 0;

 		(*tempFieldArray)[i-1].iFieldHeader.iFieldType = KNullUid;

 		(*tempFieldArray)[i-1].iFieldHeader.iField = NULL;

 		// delete all the fields wholely out of range

 		for (TInt index=i ; index<tempFieldArray->Count() ; index++)

 			(*tempFieldArray)[index].iFieldHeader.iField = NULL;

 		tempFieldArray->Delete(i,tempFieldArray->Count()-i); // pos,count

 		}

 	DoPasteL(tempFieldArray,aPos);

 	CleanupStack::PopAndDestroy(); // tempFieldArray

 	}

 EXPORT_C void CTextFieldSet::PasteComponentsL(const CStreamStore& aFieldStore,TInt aPos)

 	{

 	// Restore the fields individually from their own streams

 	TInt index; TInt offset;

 	// We don't need to make any difference between in and not in field situation here

 	// all we need is the index

 	TBool isInField = InField(aPos,index,offset);

 	DoRestoreFieldsL(iFieldArray,aFieldStore,index); 

 	}

 void CTextFieldSet::DoPasteL(CArrayFixSeg<TTextFieldEntry>* aSourceArray,TInt aPos)

 // Insert into this instance, at character position aPos, the entire (field entry) contents of the field array aSourceArray.

 // All iField objects in aSourceArray are ID's at this time.

 //

 	{

 	// are we inserting into a field?

 	TInt numFieldEntries = aSourceArray->Count();

 	TInt index; TInt offset;

 	TBool inField = InField(aPos,index,offset);

 	// record the rollback info

 	RecordRollbackInfoL(index);

 	if ((inField)&&(offset!=0))

 		{// everything we insert will become text - no chance of leaving

 		// insert all but last entry

 		TInt i=0;

 		for (; i<numFieldEntries-1 ; i++)

 			{// copy text (no need to delete field)

 			(*iFieldArray)[index].iFieldValueLen += EntryLen((*aSourceArray)[i]);

 			}

 		// read in the last entry (has no field attached)

 		(*iFieldArray)[index].iFieldValueLen += (*aSourceArray)[i].iPreFieldLen;

 		}

 	else

 		{// else split the entry we are going to bisect - this may leave

 		if (inField)

 			offset = (*iFieldArray)[index].iPreFieldLen; // must be at start of field

 		if (numFieldEntries>1)

 			{// read 1st field & carry out split.

 			InsertEntryL(index,(*aSourceArray)[0]); // if this leaves the model will be intact

 			(*iFieldArray)[index].iPreFieldLen += offset;

 			(*iFieldArray)[index+1].iPreFieldLen -= offset;

 			index++;

 			}

 		// insert all other fields except last.

 		for (TInt i=1 ; i<numFieldEntries-1 ; i++)

 			{

 			TRAPD(ret,\

 				InsertEntryL(index,(*aSourceArray)[i]));

 			if (ret!=KErrNone)

 				{// do rollback, then propagate leave

 				RollbackPaste();

 				User::Leave(ret);

 				}

 			index++;

 			}

 		// join last field up to successor

 		(*iFieldArray)[index].iPreFieldLen += (*aSourceArray)[numFieldEntries-1].iPreFieldLen;

 		}

 	__TEST_INVARIANT;

 	}

 void CTextFieldSet::RecordRollbackInfoL(TInt aIndex)

 	{

 	delete iRollbackInfo;

 	iRollbackInfo = new(ELeave) TRollbackInfo();

 	iRollbackInfo->iEntryNum = aIndex;

 	iRollbackInfo->iPreFieldLen = (*iFieldArray)[aIndex].iPreFieldLen;

 	iRollbackInfo->iFieldValueLen = (*iFieldArray)[aIndex].iFieldValueLen;

 	iRollbackInfo->iTotalEntries = iFieldArray->Count();

 	}

 EXPORT_C void CTextFieldSet::RollbackPaste()

 // Carries out rollback from a paste function

 // This will only have an effect after a PasteFromStream() has been called

 // nb it would be distasterous if this were called at random some time after a paste!

 //

 	{

 	if (!iRollbackInfo)

 		return; // nothing to do

 	// remove added entries from array

 	TInt entriesToRemove=iFieldArray->Count()-iRollbackInfo->iTotalEntries;

 	TInt i=0;

 	for (i=iRollbackInfo->iEntryNum ; i<iRollbackInfo->iEntryNum+entriesToRemove ; i++)

 		{

 		if ((*iFieldArray)[i].iFieldHeader.iField.IsPtr())

 			delete (*iFieldArray)[i].iFieldHeader.iField.AsPtr(); // Delete the textField object

 		iFieldArray->Delete(i);

 		}

 	// now right num entries, but wrong length - use backup info to correct length

 	(*iFieldArray)[i].iPreFieldLen = iRollbackInfo->iPreFieldLen;

 	(*iFieldArray)[i].iFieldValueLen = iRollbackInfo->iFieldValueLen;

 	__ASSERT_DEBUG(iFieldArray->Count()==iRollbackInfo->iTotalEntries,Panic(EDebug));

 	delete iRollbackInfo;

 	}