/*

* Copyright (c) 1997-1999 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 <s32mem.h>

#include <s32file.h>

#include <txtrich.h>

#include <basched.h>

#include <apparc.h>

#include <apgdoor.h>

#include <apacln.h>

#include <clock.h>

#include <eikrted.h>

#include <eikenv.h>

#include <eikappui.h>

#include <eikembal.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <eikdoc.h>

#else

#include <eikdoc.h>

#include <uikon/eikdefaulticondefs.h>

#include <uikon/eikenvinterface.h>

#endif

#include <eikproc.h>

#include <eikon.hrh>

#include <eikpanic.h>

#include <eikedwin.pan>

#include <eikctl.rsg>

#include <eikcoctl.rsg>

#include <AknTasHook.h>

GLDEF_C void Panic(TEikEdwinPanic aPanic)

	{

	_LIT(KPanicCat,"EIKON-EDWIN");

	User::Panic(KPanicCat,aPanic);

	}

//

// class CEikParserManager

//

const TInt KParseScanDelay	=750000; // 0.75s

const TInt KNullStartPos	=-1;

NONSHARABLE_CLASS(CEikParserManager) : public CBase, public MEikEdwinObserver

	{

public:

	static CEikParserManager* NewL(CEikRichTextEditor& aEditor);

	~CEikParserManager();

public:

	void SetParserObserver(MEikRichTextEditorParserObserver* aObserver);

	void Start(TInt aStartPos,TInt aLength);

private:

	CEikParserManager(CEikRichTextEditor& aEditor);

	void ConstructL();

	void Start();

	void StartTimer();

	void Reset();

	static TInt ParseTextCallbackL(TAny* aSelf);

	void ParseTextL();

private: // from MEikEdwinObserver

	void HandleEdwinEventL(CEikEdwin* aEdwin,TEdwinEvent aEventType);

private:

	CPeriodic* iTimer;

	CEikRichTextEditor& iEditor;

	MEikRichTextEditorParserObserver* iParserObserver;

	TInt iStartPos; // start of changed area

	TInt iLength; // length of changed area

	MParser* iParser;

	TInt iTagStart; // start of tag cursor is over

	TInt iTagLength; // length of tag cursor is over

	TBool iStateChanged;

	TBool iParseWholeText;

public: // new methods

	void ForceFullParseL();

	};

CEikParserManager* CEikParserManager::NewL(CEikRichTextEditor& aEditor)

	{ // static

	CEikParserManager* self=new(ELeave) CEikParserManager(aEditor);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CEikParserManager::~CEikParserManager()

	{

	if (iTimer)

		iTimer->Cancel();

	delete iTimer;

	}

void CEikParserManager::SetParserObserver(MEikRichTextEditorParserObserver* aObserver)

	{

	iParserObserver=aObserver;

	}

void CEikParserManager::Start(TInt aStartPos,TInt aLength)

	{

	if (iStartPos==KNullStartPos)

		iStartPos=aStartPos;

	else

		iStartPos=Min(iStartPos,aStartPos);

	if (iLength==0 || aLength>=0)

		iLength=Max(iLength,aLength);

	else // aLength<0

		iLength=Max(iLength+aLength,0);

	iStateChanged=ETrue;

	StartTimer();

	}

CEikParserManager::CEikParserManager(CEikRichTextEditor& aEditor)

	: iEditor(aEditor)

	{

	Reset();

	}

void CEikParserManager::ConstructL()

	{

	iTimer=CPeriodic::NewL(CActive::EPriorityStandard);

	iEditor.AddEdwinObserverL(this);

	}

void CEikParserManager::Start()

	{

	StartTimer();

	}

void CEikParserManager::StartTimer()

	{

	if (iTimer->IsActive())

		iTimer->Cancel();

	iTimer->Start(KParseScanDelay,KParseScanDelay,TCallBack(ParseTextCallbackL,this));

	}

void CEikParserManager::Reset()

	{

	iStartPos=KNullStartPos;

	iLength=0;

	}

TInt CEikParserManager::ParseTextCallbackL(TAny* aSelf)

	{ // static

	REINTERPRET_CAST(CEikParserManager*,aSelf)->ParseTextL();

	return 0;

	}

void CEikParserManager::ParseTextL()

	{

	TInt startPos=iStartPos;

	TInt length=iLength;

	Reset();

	iTimer->Cancel();

	const TBool foundParser=(iStateChanged && iEditor.RichText()->ParseText(startPos,length,iParseWholeText));

	iStateChanged=EFalse;

	MParser* parser=iParser;

	TInt tagStart=iTagStart;

	TInt tagLength=iTagLength;

	TInt err=KErrNone;

	TBool overNewTag=EFalse;

	if (iEditor.RichText()->CursorOverTag(iEditor.CursorPos(),parser,tagStart,tagLength))

		{

		// are we over a new tag?  Update members if so

		if ((TInt)parser!=(TInt)iParser || tagStart!=iTagStart || tagLength!=iTagLength)

			{

			overNewTag=ETrue;

			iParser=parser;

			if (iTagStart!=KNullStartPos)

				{

				TRAP(err,iEditor.TextView()->HandleRangeFormatChangeL(TCursorSelection(iTagStart,iTagStart+iTagLength),ETrue));

				}

			iTagStart=tagStart;

			iTagLength=tagLength;

			// the tag may be drawn differently when the cursor is over it

			TRAP(err,iEditor.TextView()->HandleRangeFormatChangeL(TCursorSelection(tagStart,tagStart+tagLength),ETrue));

			}

		}

	else

		{

		if (iParser)

			{

			overNewTag=ETrue; // if iParser!=NULL, we used to be over a tag and are now over a null one

			// the tag may be drawn differently now the cursor isn't over it

			TRAP(err,iEditor.TextView()->HandleRangeFormatChangeL(TCursorSelection(iTagStart,iTagStart+iTagLength),ETrue));

			}

		iParser=NULL;

		iTagStart=KNullStartPos;

		iTagLength=0;

		}

	if (foundParser && (startPos!=tagStart || length!=tagLength))

		{

		// newly identified parser is different from the one the cursor is over so...

		// change the text format for the parser also

		TRAPD(err2,iEditor.TextView()->HandleRangeFormatChangeL(TCursorSelection(startPos,startPos+length),ETrue));

		if (err==KErrNone)

			err=err2;

		}

	if (overNewTag && iParserObserver)

		{

		if (iParser)

			{

			iParserObserver->HandleCursorOverParserL(iParser->CreateDoItText(*(iEditor.RichText()),startPos,length));

			}

		else

			{

			TBuf<4> nullText(KNullDesC);

			iParserObserver->HandleCursorOverParserL(nullText);

			}

		}

	User::LeaveIfError(err);

	}

void CEikParserManager::HandleEdwinEventL(CEikEdwin* aEdwin,TEdwinEvent aEventType)

	{

	if ((TInt)aEdwin==(TInt)&iEditor && aEventType==MEikEdwinObserver::EEventNavigation)

		Start();

	}

void CEikParserManager::ForceFullParseL()

	{

	iParseWholeText = ETrue;

	iStateChanged = ETrue;

	ParseTextL();

	iParseWholeText = EFalse;

	}

//

// class CEikRichTextEditor

//

EXPORT_C CEikRichTextEditor::CEikRichTextEditor()

	{

	iEdwinUserFlags=EAllowPictures|EAllowUndo;

	iEdwinInternalFlags=ERichText;

	iDefaultIconicDoorSize=KDefaultIconicDoorSize;

	AKNTASHOOK_ADD( this, "CEikRichTextEditor" );

	}

EXPORT_C CEikRichTextEditor::CEikRichTextEditor(const TGulBorder& aBorder)

	: CEikGlobalTextEditor(aBorder)

	{

	iEdwinUserFlags=EAllowPictures|EAllowUndo;

	iEdwinInternalFlags=ERichText;

	iDefaultIconicDoorSize=KDefaultIconicDoorSize;

	AKNTASHOOK_ADD( this, "CEikRichTextEditor" );

	}

EXPORT_C CEikRichTextEditor::~CEikRichTextEditor()

	{

	AKNTASHOOK_REMOVE();

	CRichText* text=RichText();

	if (text)

	{

		text->SetEditObserver(NULL);

		}

	delete iEmbeddedDocUpdate;

	if (iEmbeddedDoc.iPicture.IsPtr())

		delete iEmbeddedDoc.iPicture.AsPtr();

	delete iParserManager;

	}

EXPORT_C void CEikRichTextEditor::ConstructL(const CCoeControl* aParent,TInt aNumberOfLines,TInt aTextLimit,

											 TInt aEdwinFlags,TInt aFontControlFlags,TInt aFontNameFlags)

	{

	CEikGlobalTextEditor::ConstructL(aParent,aNumberOfLines,aTextLimit,aEdwinFlags,aFontControlFlags,aFontNameFlags);

	CommonConstructL();

	}

EXPORT_C void CEikRichTextEditor::ConstructFromResourceL(TResourceReader& aReader)

	{

	CEikGlobalTextEditor::ConstructFromResourceL(aReader);

	CommonConstructL();

	}

void CEikRichTextEditor::CommonConstructL()

	{

	iEmbeddedDocUpdate=CIdle::NewL(EActivePriorityWsEvents+1);

	if (!(iEdwinUserFlags&ENoTextParsers))

		iParserManager=CEikParserManager::NewL(*this);

	}

EXPORT_C void CEikRichTextEditor::Draw(const TRect& aRect) const

	{

	CEikEdwin::Draw(aRect);

	}

EXPORT_C TKeyResponse CEikRichTextEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

	{

	if (aType!=EEventKey)

		return EKeyWasNotConsumed;

	if (iEdwinUserFlags&EDisplayOnly)

		return EKeyWasConsumed;

	const TInt code=aKeyEvent.iCode;

	if ((code==EKeySpace || code==EKeyEnter) && CheckForObjectL())

		return EKeyWasConsumed;

	const TInt modifiers=aKeyEvent.iModifiers;

	if (modifiers&EModifierCtrl)

		{

		TBool consumed=ETrue;

		TBuf<24> buf;

		if (aKeyEvent.iModifiers&EModifierShift)

			iCoeEnv->ReadResource(buf,R_EIK_EDWIN_SHIFT_CTRL_HOTKEYS);

		else

			iCoeEnv->ReadResource(buf,R_EIK_EDWIN_CTRL_HOTKEYS);

		const TInt pos=buf.Locate(TChar(code+'a'-1));

		switch (pos)

			{

		case EHotKeyInsertObject:

			CheckNotReadOnlyL();

			if (!(iEdwinUserFlags&EAllowPictures))

				iEikonEnv->LeaveWithInfoMsg(R_EIK_TBUF_CANNOT_INSERT_OBJECTS);

			InsertObjectL(EGlassIfPossible);

			break;

		case EHotKeyEditObject:

			CheckNotReadOnlyL();

			if (!(iEdwinUserFlags&EAllowPictures))

				return EKeyWasConsumed;

			ReEditObjectL();

			break;

		case EHotKeyFormatObject:

			CheckNotReadOnlyL();

			if (!(iEdwinUserFlags&EAllowPictures))

				return EKeyWasConsumed;

			EditPictureFormatL();

			break;

		default:

			consumed=EFalse;

			}

		if (consumed)

			return EKeyWasConsumed;

		}

	TKeyResponse response=CEikGlobalTextEditor::OfferKeyEventL(aKeyEvent,aType);

	UpdateButtonGroup();

	return response;

	}

EXPORT_C void CEikRichTextEditor::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

	CEikEdwin::HandlePointerEventL(aPointerEvent);

	}

EXPORT_C void* CEikRichTextEditor::ExtensionInterface( TUid /*aInterface*/ )

    {

    return NULL;

    }

EXPORT_C void CEikRichTextEditor::ActivateL()

	{

	SetTextObserver(*RichText());

	const TInt docLength=iText->DocumentLength();

	if( iParserManager )

		iParserManager->Start(0,docLength);

	UpdatePictureFormatL(0,docLength);

	UpdatePictureSizeL(0,docLength);

	CEikGlobalTextEditor::ActivateL();

	}

EXPORT_C void CEikRichTextEditor::HandleTextPastedL(TInt aStartPos,TInt& aLength)

	{

	UpdatePictureFormatL(aStartPos,aLength);

	UpdatePictureSizeL(aStartPos,aLength);

	}

EXPORT_C void CEikRichTextEditor::NotifyExit(TExitMode aMode)

	{

	if (aMode==MApaEmbeddedDocObserver::EEmpty)

		{

		if (iEdwinInternalFlags&EReEditingObject)

			iEmbeddedDocUpdate->Start(TCallBack(CEikRichTextEditor::TryDeleteEmbeddedDocL, this));

		else

			iEmbeddedDocUpdate->Start(TCallBack(CEikRichTextEditor::DeleteEmbeddedDoc, this));

		}

	else if (aMode==MApaEmbeddedDocObserver::ENoChanges)

		{

		if (iEdwinInternalFlags&EReEditingObject)

			iEmbeddedDoc=TPictureHeader();

		else // apps should call back with EEmpty in this case

			iEmbeddedDocUpdate->Start(TCallBack(CEikRichTextEditor::DeleteEmbeddedDoc, this));

		}

	else

		{

		if (iEdwinInternalFlags&EReEditingObject)

			iEmbeddedDocUpdate->Start(TCallBack(CEikRichTextEditor::UpdateEmbeddedDocL, this));

		else

			iEmbeddedDocUpdate->Start(TCallBack(CEikRichTextEditor::InsertEmbeddedDocL, this));

		}

	}

TInt CEikRichTextEditor::TryDeleteEmbeddedDocL(TAny *aThis)

	{ // static

	CEikRichTextEditor* editor=REINTERPRET_CAST(CEikRichTextEditor*,aThis);

	editor->iEdwinInternalFlags&=~EReEditingObject;

	if (!(CEikonEnv::Static()->QueryWinL(R_EIK_TBUF_DEL_EMPTY_OBJECT_CONFIRM_1,R_EIK_TBUF_DEL_EMPTY_OBJECT_CONFIRM_2)))

		editor->iTextView->HandleRangeFormatChangeL(editor->Selection(),EFalse);

	else

		{

		TInt docPos;

		TRect rect;

		editor->iTextView->IsPictureFrameSelected(rect,docPos);

		TBool changed=EFalse;

		editor->DeleteL(changed,TCursorSelection(docPos,docPos+1),ETrue);

		editor->iTextView->SetPendingSelection(TCursorSelection(docPos,docPos));

		editor->iTextView->HandleInsertDeleteL(TCursorSelection(docPos,docPos),1,changed);

		editor->UpdateScrollBarsL();

		if (changed)

			editor->ReportEdwinEventL(MEikEdwinObserver::EEventFormatChanged);

		}

	editor->ReportEventL(MCoeControlObserver::EEventStateChanged);

	editor->UpdateScrollBarsL();

	return 0;

	}

TInt CEikRichTextEditor::DeleteEmbeddedDoc(TAny *aThis)

	{ // static

	CEikRichTextEditor* editor=REINTERPRET_CAST(CEikRichTextEditor*,aThis);

	if (editor->iEmbeddedDoc.iPicture.IsPtr())

		delete editor->iEmbeddedDoc.iPicture.AsPtr();

	editor->iEmbeddedDoc=TPictureHeader();

	return 0;

	}

TInt CEikRichTextEditor::InsertEmbeddedDocL(TAny *aThis)

	{ // static

	CEikRichTextEditor* editor=REINTERPRET_CAST(CEikRichTextEditor*,aThis);

	TInt err=KErrNone;

	if (editor->iEdwinUserFlags&EShowAllPicturesAsIconic)

		{

		TRAPD(err,STATIC_CAST(CApaDoor*,editor->iEmbeddedDoc.iPicture.AsPtr())->SetFormatToTemporaryIconL());

		if (err)

			goto errorCheck;

		}

	TRAP(err,editor->InsertPictureL(editor->iEmbeddedDoc));

errorCheck:

	editor->iEmbeddedDoc=TPictureHeader();

	User::LeaveIfError(err);

	return 0;

	}

TInt CEikRichTextEditor::UpdateEmbeddedDocL(TAny* aThis)

	{ // static

	CEikRichTextEditor* editor=REINTERPRET_CAST(CEikRichTextEditor*,aThis);

	editor->iEdwinInternalFlags&=~EReEditingObject;

	editor->iText->SetHasChanged(ETrue);

	editor->iTextView->HandleRangeFormatChangeL(editor->Selection(),EFalse);

	editor->ReportEventL(MCoeControlObserver::EEventStateChanged);

	editor->UpdateScrollBarsL();

	return 0;

	}

EXPORT_C void CEikRichTextEditor::CopyDocumentContentL(CGlobalText& aInText,CGlobalText& aOutText)

	{

	__ASSERT_DEBUG(&aInText,Panic(EEikPanicNullPointer));

	__ASSERT_DEBUG(&aOutText,Panic(EEikPanicNullPointer));

	aOutText.Reset();

	aOutText.SetFieldFactory(CONST_CAST(MTextFieldFactory*,aInText.FieldFactory()));

	((CRichText&)aInText).DetachFromStoreL(CPicture::EDetachFull);

	iBufStore=CBufStore::NewLC(4096);

	((CRichText&)aOutText).SetPictureFactory(iEikonEnv->PictureFactory(),this);

	TStreamId streamId=aInText.StoreL(*iBufStore);

	aOutText.RestoreL(*iBufStore,streamId);

	((CRichText&)aOutText).DetachFromStoreL(CPicture::EDetachFull);

	RStoreWriteStream paraWriteStream;

	TStreamId paraStreamId=paraWriteStream.CreateLC(*iBufStore);

	(aInText.GlobalParaFormatLayer())->ExternalizeL(paraWriteStream);

	CleanupStack::PopAndDestroy(); // paraStreamId

	RStoreReadStream paraReadStream;

	paraReadStream.OpenLC(*iBufStore,paraStreamId);

	((CParaFormatLayer*)(aOutText.GlobalParaFormatLayer()))->InternalizeL(paraReadStream);

	CleanupStack::PopAndDestroy(); // paraReadStream

	RStoreWriteStream charWriteStream;

	TStreamId charStreamId=charWriteStream.CreateLC(*iBufStore);

	(aInText.GlobalCharFormatLayer())->ExternalizeL(charWriteStream);

	CleanupStack::PopAndDestroy(); // charStreamId

	RStoreReadStream charReadStream;

	charReadStream.OpenLC(*iBufStore,charStreamId);

	((CCharFormatLayer*)(aOutText.GlobalCharFormatLayer()))->InternalizeL(charReadStream);

	CleanupStack::PopAndDestroy(2); // iBufStore and charReadStream

	iBufStore=NULL;

	}

EXPORT_C const CStreamStore& CEikRichTextEditor::StreamStoreL(TInt /*aPos*/) const

	{

	return *iBufStore;

	}

EXPORT_C void CEikRichTextEditor::NewPictureL(TPictureHeader& aHdr,const CStreamStore& aDeferredPictureStore)const

	{

	iEikonEnv->PictureFactory()->NewPictureL(aHdr,aDeferredPictureStore);

	}

EXPORT_C void CEikRichTextEditor::EditObserver(TInt aStartEdit,TInt aEditLength)

	{

	if (iParserManager)

		iParserManager->Start(aStartEdit,aEditLength);

	CEikEdwin::EditObserver(aStartEdit,aEditLength);

	}

EXPORT_C CRichText* CEikRichTextEditor::RichText() const

	{

	return (CRichText*)iText;

	}

void CEikRichTextEditor::InsertPictureL(const TPictureHeader& aPictureHeader)

	{

	__ASSERT_DEBUG(iText,Panic(EEikPanicEdwinNoText));

	__ASSERT_DEBUG(iTextView,Panic(EEikPanicEdwinNoView));

	TBool formatHasChanged=EFalse;

	TCursorSelection selection=iTextView->Selection();

	const TInt selLength=selection.Length();

	const TInt oldLength=iText->DocumentLength();

	TRAPD(err,DoInsertPictureL(formatHasChanged,aPictureHeader));

	if (err!=KErrNone)

		{