/*

* 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 "WPTEXTED.H"

#include <txtrich.h>

#include <eikenv.h>

#include <word.rsg>

#include <baclipb.h>

#include <conlist.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "txtfmlyr_internal.h"

#include <txtclipboard.h>

#endif

inline TBool IsSurrogate(TText a) { return 0xD800 == (a & 0xF800); }

inline TBool IsHighSurrogate(TText a) { return 0xD800 == (a & 0xFC00); }

inline TBool IsLowSurrogate(TText a) { return 0xDC00 == (a & 0xFC00); }

inline TChar JoinSurrogates(TText aHigh, TText aLow)

	{

	return ((aHigh - 0xd7f7) << 10) + aLow;

	}

inline TText16 GetHighSurrogate(TUint aChar)

	{

	return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10));

	}

inline TText16 GetLowSurrogate(TUint aChar)

	{

	return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF));

	}

class CTestCommand : public UndoSystem::CSingleCommand

	{

	TInt ExecuteL() const { return KErrNone; }

	};

TBool CWordUndoGatekeeper::AllowNotUndoableL(TInt aReason)

	{

	if (aReason != KErrNotSupported)

		return MNotUndoableGatekeeper::AllowNotUndoableL(aReason);

	// ask user if operation should continue

	return CEikonEnv::Static()->QueryWinL(R_WORD_NOT_UNDOABLE_TITLE, R_WORD_NOT_UNDOABLE_TEXT);

	}

CWordTextEditor::CWordTextEditor(const TGulBorder& aBorder):

	CEikRichTextEditor(aBorder)

	{

	}

TKeyResponse CWordTextEditor::OfferKeyEventL(const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/)

	{

	return EKeyWasNotConsumed;

	}

CWordTextEditor::~CWordTextEditor()

	{

	if (iCommandManager)

		iCommandManager->Release();

	delete iEditorWithUndo;

	}

MUnifiedEditor& CWordTextEditor::UnifiedEditor()

	{

	ASSERT(iEditorWithUndo);

	return *iEditorWithUndo;

	}

const MUnifiedEditor& CWordTextEditor::UnifiedEditor() const

	{

	ASSERT(iEditorWithUndo);

	return *iEditorWithUndo;

	}

void CWordTextEditor::InitialiseUnifiedEditorL()

	{

	iFormAndEtextEditor.Set(*TextView(),*RichText());

	if (iCommandManager)

		{

		iCommandManager->Release();

		iCommandManager = 0;

		}

	delete iEditorWithUndo;

	iEditorWithUndo = 0;

	iCommandManager = UndoSystem::CCommandManager::NewL();

	iEditorWithUndo = CEditorWithUndo::NewL(iFormAndEtextEditor, iCommandManager);

	iEditorWithUndo->SetGatekeeper(&iGatekeeper);

	}

void CWordTextEditor::TestRunNotUndoableCommandL()

	{

	CTestCommand* command = new(ELeave) CTestCommand;

	CleanupStack::PushL(command);

	iCommandManager->ExecuteL(*command);

	CleanupStack::PopAndDestroy(command);

	}

void CWordTextEditor::InsertCharacterL(TChar aCharacter)

	{

	if ( aCharacter < 0x10000 )

		{

		//    Only surrogate high part or low part is inserted

		//    Ignore it

		if ( IsSurrogate( aCharacter ) )

		    return;

		TText c = (TText)aCharacter;

		TPtrC p(&c, 1);

		InsertTextL(iTextView->Selection().LowerPos(), p);

		}

	else

		{

		TText c[2];

		c[0] = GetHighSurrogate( aCharacter );

		c[1] = GetLowSurrogate( aCharacter );

		TPtrC p(c, 2);

		InsertTextL(iTextView->Selection().LowerPos(), p);

		}

	}

TBool CWordTextEditor::DeleteSelectionL()

	{

	TCursorSelection sel = iTextView->Selection();

	if (sel.Length())

		{

		DeleteTextL(sel.LowerPos(),sel.Length());

		return TRUE;

		}

	else

		return FALSE;

	}

void CWordTextEditor::DeleteLeftL()

	{

	if (!DeleteSelectionL())

		{

		TCursorSelection sel = iTextView->Selection();

		if (sel.iCursorPos > 0)

			DeleteTextL(sel.iCursorPos - 1, 1);

		}

	}

void CWordTextEditor::DeleteRightL()

	{

	if (!DeleteSelectionL())

		{

		TCursorSelection sel = iTextView->Selection();

		if (sel.iCursorPos < DocumentLength())

			DeleteTextL(sel.iCursorPos, 1);

		}

	}

void CWordTextEditor::HighlightL(TUint aEffects)

	{

	TTmCharFormatLayer format;

	format.iFormat.iEffects = aEffects;

	format.iFormat.iBackgroundColor = KRgbYellow;

	format.iMask.iFlags = TTmCharFormatMask::EBackground | TTmCharFormatMask::EBackgroundColor |

						  TTmCharFormatMask::EUnderline | TTmCharFormatMask::EStrikethrough |

						  TTmCharFormatMask::EShadow | TTmCharFormatMask::EUserDefinedEffects;

	TCursorSelection sel = iTextView->Selection();

	UnifiedEditor().SetCharFormatL(sel.LowerPos(),sel.Length(),format);

	}

void CWordTextEditor::RemoveHighlightL(TUint)

	{

	TCursorSelection sel = iTextView->Selection();

	TInt pos = sel.LowerPos();

	TInt length = sel.Length();

	TInt allowedFlags = ~(TTmCharFormatMask::EBackground | TTmCharFormatMask::EBackgroundColor |

						  TTmCharFormatMask::EUnderline | TTmCharFormatMask::EStrikethrough |

						  TTmCharFormatMask::EShadow | TTmCharFormatMask::EUserDefinedEffects);

	if (length == 0)

		{

		CRichText* rtext = RichText();

		TCharFormat tcf;

		TTmCharFormatMask notAllowed;

		notAllowed.iFlags = ~allowedFlags;

		TCharFormatMask tcfm;

		notAllowed.GetTCharFormatMask(tcfm);

		if (rtext)

			rtext->SetInsertCharFormatL(tcf, tcfm, pos);

		return;

		}

	iCommandManager->BeginBatchLC();

	MUnifiedEditor& ed = UnifiedEditor();

	while (0 < length)

		{

		TTmCharFormatLayer format;

		TInt runLength;

		ed.GetCharFormat(pos,

			MUnifiedEditor::ESpecific, format, runLength);

		format.iMask.iFlags &= allowedFlags;

		ed.DeleteCharFormatL(pos, length);

		ed.SetCharFormatL(pos, length, format);

		pos += runLength;

		length -= runLength;

		}

	CleanupStack::PopAndDestroy();	// batch

	}

CWordTextEditor::TAttributeValue CWordTextEditor::IsHighlighted(TUint aEffects) const

	{

	TCursorSelection sel = iTextView->Selection();

	TInt pos = sel.LowerPos();

	TInt length = sel.Length();

	const CRichText* rtext = RichText();

	if (length == 0 && rtext)

		{

		// need to find out if there is a zero length phrase. There is no

		// concept of this in MUnifiedEditor

		TCharFormat tcf;

		TCharFormatMask tcfm;

		rtext->GetCharFormat(tcf, tcfm, pos, 0);

		TTmCharFormat charFormat;

		charFormat = tcf;

		return (charFormat.iEffects & aEffects) == aEffects?

			EAttributeSet : EAttributeClear;

		}

	TUint retval = 0;

	while (retval != EAttributeIndeterminate && 0 < length)

		{

		TTmCharFormatLayer format;

		TInt runLength;

		UnifiedEditor().GetCharFormat(pos,

			MUnifiedEditor::EEffective, format, runLength);

		if ((format.iFormat.iEffects & aEffects) == aEffects)

			retval |= EAttributeSet;

		else

			retval |= EAttributeClear;

		pos += runLength;

		length -= runLength;

		}

	return static_cast<TAttributeValue>(retval);

	}

void CWordTextEditor::ToggleHighlightL(TUint aEffects)

	{

	if (IsHighlighted(aEffects) == EAttributeSet)

		RemoveHighlightL(aEffects);

	else

		HighlightL(aEffects);

	}

void CWordTextEditor::BoldItalicUnderlineEventL(TInt aFontFlag)

	{

	TCursorSelection sel = iTextView->Selection();

	if (sel.Length())

		{

		TTmCharFormatLayer old_format;

		TInt run_length;

		GetCharFormat(sel.LowerPos(),MUnifiedEditor::EEffective,old_format,run_length);

		TTmCharFormatLayer new_format;

		new_format.iMask.iFlags = 0;

		if (aFontFlag & EBold)

			{

			new_format.iMask.Set(TTmCharFormatMask::EBold);

			new_format.iFormat.iFontSpec.SetBold(!old_format.iFormat.iFontSpec.IsBold());

			}

		if (aFontFlag & EItalic)

			{

			new_format.iMask.Set(TTmCharFormatMask::EItalic);

			new_format.iFormat.iFontSpec.SetItalic(!old_format.iFormat.iFontSpec.IsItalic());

			}

		if (aFontFlag & EUnderline)

			{

			new_format.iMask.Set(TTmCharFormatMask::EUnderline);

			if (!(old_format.iFormat.iEffects & TTmCharFormat::EUnderline))

				new_format.iFormat.iEffects |= TTmCharFormat::EUnderline;

			}

		SetCharFormatL(sel.LowerPos(),sel.Length(),new_format);

		}

	else

		CEikGlobalTextEditor::BoldItalicUnderlineEventL(aFontFlag);

	}

TInt CWordTextEditor::DocumentLength() const

	{

	return UnifiedEditor().DocumentLength();

	}

void CWordTextEditor::GetText(TInt aPos,TPtrC& aText) const

	{

	UnifiedEditor().GetText(aPos,aText);

	}

void CWordTextEditor::GetBaseFormatL(TTmCharFormat& aCharFormat,RTmParFormat& aParFormat) const

	{

	UnifiedEditor().GetBaseFormatL(aCharFormat,aParFormat);

	}

void CWordTextEditor::GetCharFormat(TInt aPos,TFormatLevel aLevel,

		TTmCharFormatLayer& aFormat,TInt& aRunLength) const

	{

	UnifiedEditor().GetCharFormat(aPos,aLevel,aFormat,aRunLength);

	}

void CWordTextEditor::GetParFormatL(TInt aPos,TFormatLevel aLevel,

		RTmParFormatLayer& aFormat,TInt& aRunLength) const

	{

	UnifiedEditor().GetParFormatL(aPos,aLevel,aFormat,aRunLength);

	}

void CWordTextEditor::InsertTextL(TInt aPos,const TDesC& aText,

		 const TDesC* aStyle,

		 const TTmCharFormatLayer* aCharFormat,

		 const RTmParFormatLayer* aParFormat)

	{

	DeleteSelectionL();

	UnifiedEditor().InsertTextL(aPos,aText,aStyle,aCharFormat,aParFormat);

	UpdateScrollBarsL();

	}

void CWordTextEditor::DeleteTextL(TInt aPos,TInt aLength)

	{

	UnifiedEditor().DeleteTextL(aPos,aLength);

	UpdateScrollBarsL();

	}

void CWordTextEditor::SetBaseFormatL(const TTmCharFormat& aCharFormat,const RTmParFormat& aParFormat)

	{

	UnifiedEditor().SetBaseFormatL(aCharFormat,aParFormat);

	UpdateScrollBarsL();

	}

void CWordTextEditor::SetCharFormatL(TInt aPos,TInt aLength,const TTmCharFormatLayer& aFormat)

	{

	UnifiedEditor().SetCharFormatL(aPos,aLength,aFormat);

	UpdateScrollBarsL();

	}

void CWordTextEditor::SetParFormatL(TInt aPos,TInt aLength,const RTmParFormatLayer& aFormat)

	{

	UnifiedEditor().SetParFormatL(aPos,aLength,aFormat);

	UpdateScrollBarsL();

	}

void CWordTextEditor::DeleteCharFormatL(TInt aPos,TInt aLength)

	{

	UnifiedEditor().DeleteCharFormatL(aPos,aLength);

	UpdateScrollBarsL();

	}

void CWordTextEditor::DeleteParFormatL(TInt aPos,TInt aLength)

	{

	UnifiedEditor().DeleteParFormatL(aPos,aLength);

	UpdateScrollBarsL();

	}

MTmOptionalInterface* CWordTextEditor::Interface(TUint aId)

	{

	return UnifiedEditor().Interface(aId);

	}

void CWordTextEditor::HandleResourceChange(TInt aType)

	{

	CEikBorderedControl::HandleResourceChange(aType);

	switch (aType)

		{

	case KEikMessageCapsLock:

		break;

	case KEikMessageVirtualCursorStateChange:

		{

		TEikVirtualCursor& cursor=iEikonEnv->VirtualCursor();

		if(!(iEdwinUserFlags&EIgnoreVirtualCursor) && IsFocused()

			&& cursor.CursorState(*iEikonEnv)==TEikVirtualCursor::EOn)

			{

			// This doesn't leave

			cursor.SetCursorStateL(TEikVirtualCursor::ESuspended,*iEikonEnv);

			}

		}

		break;

	default:

		break;

		}

	}

void CWordTextEditor::FocusChanged(TDrawNow /*aDrawNow*/)

	{

	if (!iTextView)

		return;

	const TBool focused=IsFocused();

	const TCursor::TVisibility textCursor=(focused? TCursor::EFCursorFlashing : TCursor::EFCursorInvisible);

	const TCursor::TVisibility lineCursor=((iEdwinUserFlags&ELineCursor && focused)? 

										TCursor::EFCursorVisible : TCursor::EFCursorInvisible);

	TRAPD(ignored,iTextView->SetCursorVisibilityL(lineCursor,textCursor));

	if (!focused && iEdwinUserFlags&EAlwaysShowSelection)

		;

	else

		{

		TRAP(ignored,iTextView->SetSelectionVisibilityL(focused)); // !! inefficient

		}

	//TRAP(ignored,SetVirtualCursorStateL(focused));	// virtual cursor not supported in RefUi word.

	}

TInt CWordTextEditor::ClipboardPasteL()

	{

	MUnifiedEditor::MClipboardSupport* ci = iEditorWithUndo->ClipboardSupport();

	if (!ci)

		return KErrNotSupported;

	CClipboard* cb = CClipboard::NewForReadingLC(iCoeEnv->FsSession());

	if (cb->StreamDictionary().At(KClipboardUidTypePlainText) == KNullStreamId)

		{

		CleanupStack::PopAndDestroy(cb);

		return KErrNotFound;

		}

	iCommandManager->BeginBatchLC();		// batch together the delete and insert

	DeleteSelectionL();

	ci->PasteFromStoreL(cb->Store(), cb->StreamDictionary(),

		iTextView->Selection().iCursorPos);

	CleanupStack::PopAndDestroy();		// close batch

	CleanupStack::PopAndDestroy(cb);

	UpdateScrollBarsL();

	return KErrNone;

	}

void CWordTextEditor::ClipboardCutL()

	{

	ClipboardCopyL();

	DeleteSelectionL();

	}

void CWordTextEditor::ClipboardCopyL() const

	{

	MUnifiedEditor::MClipboardSupport* ci = iEditorWithUndo->ClipboardSupport();

	if (!ci)

		return;

	TCursorSelection sel = iTextView->Selection();

	if (!sel.Length())

		return;

	CClipboard* cb = CClipboard::NewForWritingLC(iCoeEnv->FsSession());

	ci->CopyToStoreL(cb->Store(), cb->StreamDictionary(), sel.LowerPos(), sel.Length());

	cb->CommitL();

	CleanupStack::PopAndDestroy(cb);

	}

void CWordTextEditor::SetBookmark()

	{

	iCommandManager->SetBookmark();

	}

TBool CWordTextEditor::IsAtBookmark() const

	{

	return iCommandManager->IsAtBookmark();

	}

void CWordTextEditor::ResetUndo()

	{

	iCommandManager->ResetUndo();

	}

void CWordTextEditor::InsertFromHtmlFileL(const TDesC& aFileName)

	{

	//get converter

	CCnaConverterList* convList=CCnaConverterList::NewLC();

	const TUid KUidCHtmlToCrtConverter = {0x1000a90e};

	CConverterBase* conv = convList->NewConverterL(KUidCHtmlToCrtConverter);

	if (conv)

		{

		//do conversion

		CleanupStack::PushL(conv);

		_LIT(KTempRichTextDestinationFile, "_:\\System\\Temp\\TempRichText");

		TFileName richtextdestFile(KTempRichTextDestinationFile);

		richtextdestFile[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());

		conv->ConvertL(aFileName, richtextdestFile);	

		CleanupStack::PopAndDestroy(conv);

		CancelFepTransaction();

		const TInt oldLength = iText->DocumentLength();

		const TInt cursorPos=CursorPos();

		CDirectFileStore* directFileStore=CDirectFileStore::OpenLC(iCoeEnv->FsSession(), richtextdestFile, EFileShareReadersOnly);

		TStreamId streamId(directFileStore->Root());

		RStoreReadStream readStream;

		CStreamDictionary* dictionary=CStreamDictionary::NewLC();

		readStream.OpenLC(*directFileStore, streamId);

		readStream>>*dictionary;

		User::LeaveIfError(iText->PasteFromStoreL(*directFileStore, *dictionary, cursorPos));

		CleanupStack::PopAndDestroy(3);//readStream, dictionary, directFileStore

		iCoeEnv->FsSession().Delete(richtextdestFile);

		const TInt KFullFormattingUpperThreshold=2000;//already defined in \uikon\coctlsrc\eikedwin.cpp

		CheckValidityOfChars(oldLength,(iText->DocumentLength()-oldLength));

		const TInt newLength=iText->DocumentLength();

		const TInt newCursorPos=cursorPos+newLength-oldLength;

		iTextView->SetPendingSelection(TCursorSelection(newCursorPos,newCursorPos));

		if (newLength>KFullFormattingUpperThreshold &&

			oldLength<=KFullFormattingUpperThreshold)

			SetAmountToFormatL();

		else

			iTextView->HandleInsertDeleteL(TCursorSelection(newCursorPos,cursorPos),0,ETrue);

		DrawContents();

		UpdateScrollBarsL();

		ReportEventL(MCoeControlObserver::EEventStateChanged);

		iEikonEnv->BusyMsgCancel();

		}

	else

		{

		iEikonEnv->InfoMsg(R_WORD_NO_HTML_CONVERTER);