/*

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

#include <s32strm.h>

#include <s32stor.h>

#include <s32mem.h>

#include <s32file.h>

#include <s32ucmp.h>

#include <fepitfr.h>

#include "FLDDEF.H"

#include "FLDINFO.H"

#include "FLDSET.H"

#include "TXTETEXT.H"

#include "TXTRICH.H"

#include "TXTOPT.H"

#include "TXTFEP.H"

#include "TXTPLAIN.H"

#include "TXTSTD.H"

#include "TXTRTPFL.H"

#include "TXTCLIPBOARD.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TXTETEXT_INTERNAL.H"

#endif

const TUint KFieldCountLimit = 255;

#define UNUSED_VAR(a) a = a

// Write some or all of the text in a buffer to a stream, writing the length first if aWriteLength is true.

static void ExternalizeTextL(RWriteStream& aStream,const CBufBase& aText,TInt aPos,TInt aLength,TBool aWriteLength)

	{

	if (aWriteLength)

		aStream << TCardinality(aLength);

	// Use the Standard Unicode Compression Scheme.

	RBufReadStream input_stream(aText,aPos * sizeof(TText));

	TMemoryStreamUnicodeSource source(input_stream);

	TUnicodeCompressor c;

	c.CompressL(aStream,source,KMaxTInt,aLength);

	input_stream.Close();

	}

// Read text from a stream and write it to a buffer.

static void InternalizeTextL(RReadStream& aStream,CBufBase& aText,TInt aLength)

	{

	// Use the Standard Unicode Compression Scheme.

	RBufWriteStream output_stream(aText);

	TMemoryStreamUnicodeSink sink(output_stream);

	TUnicodeExpander e;

	e.ExpandL(sink,aStream,aLength);

	output_stream.CommitL();

	output_stream.Close();

	}

// Read text from a stream and write it to a buffer; read the length first.

static void InternalizeTextL(RReadStream& aStream,CBufBase& aText)

	{

	TCardinality length;

	aStream >> length;

	InternalizeTextL(aStream,aText,length);

	}

/**

Returns the interface corresponding to the

specified UID if it exists, or 0 if not. Overridden

versions should base call rather than returning 0.

@param aInterfaceId The UID indicating the interface to return

@param aInterface The interface corresponding to aInterfaceId

if it is supported, or 0 if it is not

*/

EXPORT_C void CEditableText::ExtendedInterface(TAny*& /*aInterface*/, TUid /*aInterfaceId*/) {}

/**

Returns the interface corresponding to the

specified UID if it exists, or 0 if not. Overridden

versions should base call rather than returning 0.

@param aInterfaceId The UID indicating the interface to return

@param aInterface The interface corresponding to aInterfaceId

if it is supported, or 0 if it is not

*/

EXPORT_C void CPlainText::ExtendedInterface(TAny*& /*aInterface*/, TUid /*aInterfaceId*/) {}

/**

 @internalAll

 @released

 */

EXPORT_C void CPlainText::Reserved_2() {}

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

// CEditableText

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

EXPORT_C CEditableText::~CEditableText()

	{

	delete iOptionalData;

	}

EXPORT_C TInt CEditableText::ScanWords(TInt& /*aPos*/,TUint& /*aScanMask*/) const

/** Scans the text from a specified document position to a location 

determined by the flags specified in a bitmask. The function can scan 

forwards or backwards to the beginning or end of a word.

@param aPos A valid document position from which to scan. On return, 

contains the new document position. 

@param aScanMask The scan mask to use. See the scanning enumeration defined 

in class CPlainText. 

@return The number of characters skipped to reach the new document position. 

Notes: If the scan passes the end of text delimiter, on return, aPos is set 

to EScanEndOfData  and the function's return value indicates the 

number of characters skipped in passing the end of text delimiter. */

	{

	return 0;

	}

EXPORT_C TInt CEditableText::ScanParas(TInt& /*aPos*/,TUint& /*aScanMask*/) const

/** Scans the text from a specified document position to a location determined 

by the flags specified in a bitmask. The function can scan forwards or backwards 

to the beginning or end of a paragraph.

@param aPos A valid document position from which to scan. On return, contains 

the new document position. 

@param aScanMask The scan mask to use. See the scanning enumeration defined 

in class CPlainText. 

@return The number of characters skipped to reach the new document position. 

Notes: If the scan passes the end of text delimiter, on return, aPos is set 

to EScanEndOfData  and the function's return value indicates the 

number of characters skipped in passing the end of text delimiter. */

	{

	return 0;

	}

EXPORT_C void CEditableText::SetHasChanged(TBool aHasChanged)

/** Sets whether a change has occurred to the editable text object. This is called 

by functions which change the text object in some way.

@param aHasChanged ETrue if a change has occurred to the text object. EFalse 

if no change has occurred. */

	{

	iHasChanged = aHasChanged;

	}

// Save the editable text type identifier.

void CEditableText::ExternalizeL(RWriteStream& aStream)const

	{

	aStream << KEditableTextUid;

	}

void CEditableText::InternalizeL(RReadStream& aStream)

// Read from the stream, expecting the editable text type identifier

//

	{

	TUid uid;

	aStream>> uid;

	if (uid!=KEditableTextUid)

		User::Leave(KErrCorrupt);

	}

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

/** Stores the text and its components. The components (e.g. fields and pictures) 

are stored in separate streams within the stream store.

@param aStore Stream store to which the text and text components are written. 

@return The ID of the stream store. */

	{

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

	StoreComponentsL(aStore,*map);

//

	RStoreWriteStream stream(*map);

	TStreamId id=stream.CreateLC(aStore);

	stream<< *this;

	stream.CommitL();

//

	map->Reset();

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

	return id;

	}

EXPORT_C void CEditableText::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)

/** Restores the text and its components from a stream store.

@param aStore Stream store containing the text and its components. 

@param aStreamId The ID of the stream store in which the text was previously 

stored. */

	{

	// Load text and field components only.  (Pictures, if present, are deferred loaded).

	__ETEXT_WATCH(RESTORE)

	RStoreReadStream stream;

	stream.OpenLC(aStore,aStreamId);

	//

	stream>> *this;

	CleanupStack::PopAndDestroy();  // stream

	RestoreComponentsL(aStore);

	__ETEXT_WATCH_END(RESTORE)

	}

TBool CEditableText::DeleteWithoutDestroyingFormatL(TInt aPos, TInt aLength)

/** Deletes a range of characters. For rich text the format of the deleted character 

at position aPos is preserved, so that any text subsequently inserted at aPos will have 

that format applied to it.

@param aPos The document position from which to begin deleting including aPos.

@param aLength The number of characters to delete. Must be positive or a panic 

occurs. The sum of aPos and aLength must be less than the document length, 

or a panic occurs.  

@return Indicates whether two paragraphs have been merged together as a result 

of the delete, indicating that the resulting paragraph must be reformatted. 

*/	

	{

	TAny* richTextInterface = NULL;	

	ExtendedInterface(richTextInterface, KUidRichText);

	if(richTextInterface)

		{

		return REINTERPRET_CAST(CRichText*, richTextInterface)->DelSetInsertCharFormatL(aPos, aLength);

		}

	else

		{

		return DeleteL(aPos, aLength);

		}

	}

EXPORT_C void CEditableText::StartFepInlineEditL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument,const TDesC& aInitialInlineText,TInt aPositionOfInlineTextInDocument,TInt aNumberOfCharactersToHide,MFepInlineTextFormatRetriever& aInlineTextFormatRetriever)

/** @internalAll */	

	{

	__ASSERT_ALWAYS(aPositionOfInlineTextInDocument>=0 && aNumberOfCharactersToHide>=0 && aPositionOfInlineTextInDocument+aNumberOfCharactersToHide<=DocumentLength(),Panic(ECharPosBeyondDocument));

	__ASSERT_ALWAYS(InlineEditData()==NULL,Panic(EAlreadyFepInlineEditing));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	CInlineEditData* const inlineEditData=new(ELeave) CInlineEditData;

	CleanupStack::PushL(inlineEditData);

	HBufC* hiddenText=NULL;

	CleanupStack::PushL(hiddenText);

	if (aNumberOfCharactersToHide>0)

		{

		CleanupStack::Pop(); // hiddenText

		hiddenText=HBufC::NewLC(aNumberOfCharactersToHide);

		TPtr hiddenTextAsWritableDescriptor=hiddenText->Des();

		Extract(hiddenTextAsWritableDescriptor,aPositionOfInlineTextInDocument,aNumberOfCharactersToHide);

		aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(aPositionOfInlineTextInDocument,aNumberOfCharactersToHide);

		aNumberOfCharactersSuccessfullyDeleted=aNumberOfCharactersToHide;

		aPositionOfInsertionPointInDocument=aPositionOfInlineTextInDocument;

		}

	inlineEditData->iPositionOfInlineTextInDocument=aPositionOfInlineTextInDocument;

	inlineEditData->iLengthOfInlineText=aInitialInlineText.Length();

	inlineEditData->iInlineText=aInitialInlineText.AllocL();

	inlineEditData->iHiddenText=hiddenText;

	CleanupStack::Pop(); // hiddentext now owned by inlineEditData. 

	inlineEditData->iInlineTextFormatRetriever=&aInlineTextFormatRetriever;

	InsertL(aPositionOfInlineTextInDocument,aInitialInlineText);

	SetAndTransferOwnershipOfInlineEditDataL(inlineEditData);

	CleanupStack::Pop(); // inlineEditData

	aNumberOfCharactersSuccessfullyInserted=inlineEditData->iLengthOfInlineText;

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	}

EXPORT_C void CEditableText::UpdateFepInlineTextL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument,const TDesC& aNewInlineText)

/** @internalAll */	

    {

	CInlineEditData* const inlineEditData=InlineEditData();

	__ASSERT_ALWAYS(inlineEditData!=NULL,Panic(ENotCurrentlyFepInlineEditing));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	HBufC*& inlineText=inlineEditData->iInlineText;

	HBufC* oldInlineText=inlineText;

	__ASSERT_DEBUG(oldInlineText==NULL || inlineEditData->iLengthOfInlineText==oldInlineText->Length(),Panic(EDebug));

	const TInt lengthOfNewInlineText=aNewInlineText.Length();

	if (oldInlineText!=NULL && *oldInlineText==aNewInlineText)

		{

		aNumberOfCharactersSuccessfullyDeleted=lengthOfNewInlineText;

		aNumberOfCharactersSuccessfullyInserted=lengthOfNewInlineText;

		}

	else

		{

		if (oldInlineText==NULL)

			{

			oldInlineText=HBufC::NewL(lengthOfNewInlineText);

			}

		else if (lengthOfNewInlineText>oldInlineText->Length())

			{

			oldInlineText=oldInlineText->ReAllocL(lengthOfNewInlineText);

			}

		CleanupStack::PushL(oldInlineText);

		inlineText=NULL; // sets inlineEditData->iLengthOfInlineText in case either the delete or the insert leaves

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		TInt& lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		if (lengthOfInlineText>0)

			{

			aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(positionOfInlineTextInDocument,lengthOfInlineText);

			aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

			lengthOfInlineText=0; // sets inlineEditData->iLengthOfInlineText in case the insert leaves

			aPositionOfInsertionPointInDocument=inlineEditData->iPositionOfInlineTextInDocument;

			}

		InsertL(positionOfInlineTextInDocument,aNewInlineText);

		lengthOfInlineText=aNewInlineText.Length(); // sets inlineEditData->iLengthOfInlineText

		aNumberOfCharactersSuccessfullyInserted=lengthOfInlineText;

		inlineText=oldInlineText;

		CleanupStack::Pop(); // oldInlineText

		*oldInlineText=aNewInlineText;

		}

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	}

EXPORT_C void CEditableText::CommitFepInlineEditL(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument)

/**

 * @internalAll

 */	

    {

	const CInlineEditData* const inlineEditData=InlineEditData();

	__ASSERT_ALWAYS(inlineEditData!=NULL,Panic(ENotCurrentlyFepInlineEditing));

	__ASSERT_DEBUG(inlineEditData->iInlineText==NULL || inlineEditData->iLengthOfInlineText==inlineEditData->iInlineText->Length(),Panic(EDebug));

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

	aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

	aNumberOfCharactersSuccessfullyInserted=lengthOfInlineText;

	aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

	DeleteInlineEditDataAndSetToNull();

	}

EXPORT_C void CEditableText::CancelFepInlineEdit(TBool& aParagraphContainingStartPositionOfInlineTextHasChangedFormat,TInt& aNumberOfCharactersSuccessfullyDeleted,TInt& aNumberOfCharactersSuccessfullyInserted,TInt& aPositionOfInsertionPointInDocument,TInt aNewPositionOfInsertionPointInDocument)

/**

 * @internalAll

 */	

    {

	aParagraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;

	aNumberOfCharactersSuccessfullyDeleted=0;

	aNumberOfCharactersSuccessfullyInserted=0;

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData!=NULL)

		{

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		__ASSERT_DEBUG(inlineEditData->iInlineText==NULL || lengthOfInlineText==inlineEditData->iInlineText->Length(),Panic(EDebug));

		TRAPD(notUsed,

						if (lengthOfInlineText>0)

							{

							aParagraphContainingStartPositionOfInlineTextHasChangedFormat=DeleteWithoutDestroyingFormatL(positionOfInlineTextInDocument,lengthOfInlineText);

							aNumberOfCharactersSuccessfullyDeleted=lengthOfInlineText;

							aPositionOfInsertionPointInDocument=inlineEditData->iPositionOfInlineTextInDocument;

							}

						const HBufC* const hiddenText=inlineEditData->iHiddenText;

						if (hiddenText!=NULL)

							{

							__ASSERT_DEBUG(hiddenText->Length()>0, Panic(EDebug));

							InsertL(positionOfInlineTextInDocument,*hiddenText);

							aNumberOfCharactersSuccessfullyInserted=hiddenText->Length();

							aPositionOfInsertionPointInDocument=aNewPositionOfInsertionPointInDocument;

							}

			);

        UNUSED_VAR(notUsed);

		DeleteInlineEditDataAndSetToNull();

		}

	}

EXPORT_C void CEditableText::OverrideFormatOfInlineTextIfApplicable(TPtrC& aView,TCharFormat& aFormat,TInt aStartPos)const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData!=NULL)

		{

		const TInt positionOfInlineTextInDocument=inlineEditData->iPositionOfInlineTextInDocument;

		const TInt lengthOfInlineText=inlineEditData->iLengthOfInlineText;

		const TInt originalLengthOfView=aView.Length();

		TInt maximumLengthOfView=originalLengthOfView;

		if (aStartPos<positionOfInlineTextInDocument)

			{

			maximumLengthOfView=positionOfInlineTextInDocument-aStartPos;

			}

		else if (aStartPos<positionOfInlineTextInDocument+lengthOfInlineText)

			{

			inlineEditData->iInlineTextFormatRetriever->GetFormatOfFepInlineText(aFormat,maximumLengthOfView,aStartPos-positionOfInlineTextInDocument);

			}

		if (originalLengthOfView>maximumLengthOfView)

			{

			aView.Set(aView.Left(maximumLengthOfView));

			}

		}

	}

EXPORT_C TInt CEditableText::GetPositionOfInlineTextInDocument() const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

		return KErrNotFound;

	return inlineEditData->iPositionOfInlineTextInDocument;	

	}

EXPORT_C TInt CEditableText::GetLengthOfInlineText() const

	{

	const CInlineEditData* inlineEditData=InlineEditData();

	if (inlineEditData==NULL)

		return KErrNotFound;

	return inlineEditData->iLengthOfInlineText;		

	}

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

// TEtextComponentInfo

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

EXPORT_C TEtextComponentInfo::TEtextComponentInfo()

	: iFieldCount(0),iPictureCount(0),iStyleCount(0)

/** C++ constructor overloaded function.

The object can be constructed either:by default this initializes the

field, picture and style counts to zerowith a field, picture and style

count

@param aFieldCount Specifies the number of fields in the text object.

@param aPictureCount Specifies the number of pictures in the text object

(rich text only).

@param aStyleCount  Specifies the number of styles owned or referenced by

the text object (rich text only). */

    {}

EXPORT_C TEtextComponentInfo::TEtextComponentInfo(TInt aFieldCount,TInt aPictureCount,TInt aStyleCount)

	: iFieldCount(aFieldCount),iPictureCount(aPictureCount),iStyleCount(aStyleCount)

/** C++ constructor overloaded function. The object can be constructed either:

by default  this initializes the field, picture and style counts to zero

with a field, picture and style count

@param aFieldCount Specifies the number of fields in the text object. 

@param aPictureCount Specifies the number of pictures in the text object (rich 

text only). 

@param aStyleCount Specifies the number of styles owned or referenced by the 

text object (rich text only). */

	{}

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

// CPlainText

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

EXPORT_C void CPlainText::__DbgTestInvariant()const

// Provides class invariants.  Explanations below:

//

	{

#ifdef _DEBUG

// ASSERT: Storage handle is good.

	__ASSERT_DEBUG(iByteStore!=NULL,User::Invariant());

// ASSERT: The text component must be non-negative in length

	__ASSERT_DEBUG(DocumentLength()>=0,User::Invariant());

#endif

	}

EXPORT_C CPlainText* CPlainText::NewL(TDocumentStorage aStorage,TInt aDefaultTextGranularity)

/** Allocates and constructs a plain text object overloaded function.

The text object's contents may be restored from a stream store. If the

text object supports fields, a field factory should be specified.

@param aStorage  The type of in-memory buffer to use. Defaults to ESegmentedStorage.

@param aDefaultTextGranularity  Specifies the granularity of the in-memory 

buffer. Default is EDefaultTextGranularity bytes (=256).

@param aStore   Stream store from which the object is restored.

@param aStreamId  ID of the stream store.

@param aFieldFactory Pointer to a field factory. A field factory must be

provided if the text object supports the addition of fields.

@return Pointer to the new plain text object. */	

	{

	CPlainText* self=new(ELeave) CPlainText();

	CleanupStack::PushL(self);

	self->ConstructL(aStorage,aDefaultTextGranularity);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CPlainText* CPlainText::NewL(const CStreamStore& aStore,TStreamId aStreamId,MTextFieldFactory* aFieldFactory,TDocumentStorage aStorage)

/** Returns a handle to a new instance of this class, restored from the specified

read stream.*/

	{

	CPlainText* self=new(ELeave) CPlainText();

	CleanupStack::PushL(self);

	self->ConstructL(aStore,aStreamId,aFieldFactory,aStorage);

	CleanupStack::Pop();

	return self;

	}