/*
* Copyright (c) 2000-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 "EditorPlainTextCommands.h"
#include "AssertFileAndLine.h"
#include <txtetext.h>
#include <txtclipboard.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include "txtfmlyr_internal.h"
#endif
using namespace UndoSystem;

/////////////////////////
//					   //
//	Internal Commands  //
//					   //
/////////////////////////

TUid CEditorCommand::FamilyUid() const { return TUid::Uid(KUndoDllUid); }

CEditorCommandInsertTextAndFormat*
	CEditorCommand::CastToCEditorCommandInsertTextAndFormat() { return 0; }
CEditorCommandDeleteText*
	CEditorCommand::CastToCEditorCommandDeleteText() { return 0; }
CEditorCommandInsertPlainText*
	CEditorCommand::CastToCEditorCommandInsertPlainText() { return 0; }
CEditorCommandDeletePlainText*
	CEditorCommand::CastToCEditorCommandDeletePlainText() { return 0; }
CEditorCommandDeleteCharFormat*
	CEditorCommand::CastToCEditorCommandDeleteCharFormat() { return 0; }
CEditorCommandDeleteParFormat*
	CEditorCommand::CastToCEditorCommandDeleteParFormat() { return 0; }

/////////////////////////////////
//							   //
//	Command coalesce function  //
//							   //
/////////////////////////////////

CCommand* UndoSystem::CoalesceL(CCommand* aLeft, CCommand* aRight)
	{
	if (!aRight)
		return aLeft;
	if (!aLeft)
		return aRight;

	CleanupStack::PushL(aRight);
	CBatchCommand* batch = aLeft->Batch();
	if (batch)
		{
		batch->PrepareToPushL(aRight);
		batch->Push(aRight);
		CleanupStack::Pop(aRight);
		return batch;
		}
	ASSERT(aLeft->Single());
	batch = CBatchCommand::NewL();
	CleanupStack::PushL(batch);
	batch->PrepareToPushL(aLeft);
	batch->Push(aLeft);
	batch->PrepareToPushL(aRight);
	batch->Push(aRight);
	CleanupStack::Pop(batch);
	CleanupStack::Pop(aRight);
	return batch;
	}

/**
 * Command for deleting plain text.
 *
 * @internalComponent
 * @since App-frameworks6.1
 */
NONSHARABLE_CLASS(CEditorCommandDeletePlainText) : public CEditorCommand
	{
	TEditorDeletePlainTextImpl iImpl;

	CEditorCommandDeletePlainText*
		CastToCEditorCommandDeletePlainText() { return this; }

	CEditorCommandDeletePlainText(MUnifiedEditor& aTarget,
		TInt aPos, TInt aLength)
		: iImpl(aTarget, aPos, aLength) {}
public:
	static CEditorCommandDeletePlainText* NewL(TInt aPos,
		TInt aLength, MUnifiedEditor& aTarget)
		{
		return new(ELeave) CEditorCommandDeletePlainText(aTarget, aPos, aLength);
		}

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const
		{
		return iImpl.ExecuteL();
		}

	// This command can be coalesced with others of the same type
	TBool CanAdd(TInt aPos, TInt aLength, MUnifiedEditor& aTarget) const
		{
		return iImpl.CanAdd(aPos, aLength, aTarget);
		}

	void Add(TInt aLength)
		{
		iImpl.Add(aLength);
		}
	};

/**
 * Command for inserting text in a specified style and format.
 *
 * @internalComponent
 * @since App-frameworks6.1
 */
NONSHARABLE_CLASS(CEditorCommandInsertPlainText) : public CEditorCommand
	{
	TEditorInsertPlainTextImpl iImpl;

	CEditorCommandInsertPlainText*
		CastToCEditorCommandInsertPlainText() { return this; }
	CEditorCommandInsertPlainText(MUnifiedEditor& aTarget, TInt aPos, const TDesC& aText)
		: iImpl(aTarget, aPos, aText) {}
public:
	static CEditorCommandInsertPlainText* NewL(TInt aPos, const TDesC& aText,
		MUnifiedEditor& aTarget)
		{
		return new(ELeave) CEditorCommandInsertPlainText(aTarget, aPos, aText);
		}
	/**
	 * Gets the length specified, but this might entail the use of more than
	 * one CCommand object.
	 */
	static CCommand* NewBatchL(TInt aPos, TInt aLength, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const
		{
		return iImpl.ExecuteL();
		}

	TBool CanAdd(TInt aPos, const TDesC& aText, MUnifiedEditor& aTarget) const
		{
		return iImpl.CanAdd(aPos, aText, aTarget);
		}

	void Add(TInt aPos, const TDesC& aText)
		{
		iImpl.Add(aPos, aText);
		}
	};

CCommand* CEditorCommandInsertPlainText::NewBatchL(TInt aPos,
	TInt aLength, MUnifiedEditor& aTarget)
	{
	CCommand* command = 0;
	TInt end = aPos + aLength;
	while (aLength)
		{
		TPtrC textSegment;
		aTarget.GetText(end - aLength, textSegment);
		TInt segLength = textSegment.Length();
		if (aLength < segLength)
			segLength = aLength;
		if (KMaxCharsInSingleCommand < segLength)
			segLength = KMaxCharsInSingleCommand;
		CleanupStack::PushL(command);
		// coverity[double_free]
		command = CoalesceL(command, CEditorCommandInsertPlainText::NewL(aPos,
			textSegment.Left(segLength), aTarget));
		CleanupStack::Pop();
		aLength -= segLength;
		}
	return command;
	}

CCommand* CEditorCommandInsertPlainText::CreateInverseL() const
	{
	return CEditorCommandDeletePlainText::NewL(iImpl.Pos(), iImpl.Text().Length(),
		iImpl.Target());
	}


CCommand* CEditorCommandDeletePlainText::CreateInverseL() const
	{
	return CEditorCommandInsertPlainText::NewBatchL(iImpl.Pos(), iImpl.Length(),
		iImpl.Target());
	}

//////////////////////////////////////////
//										//
//	CEditorCommandInsertPlainTextProto  //
//										//
//////////////////////////////////////////

void CEditorCommandInsertPlainTextProto::Set(TInt aPos, const TDesC& aText)
	{
	iPos = aPos;
	iText = &aText;
	}

UndoSystem::CCommand* CEditorCommandInsertPlainTextProto::CreateInverseL() const
	{
	return CEditorCommandDeletePlainText::NewL(iPos, iText->Length(), iTarget);
	}

TInt CEditorCommandInsertPlainTextProto::ExecuteL() const
	{
	iTarget.InsertTextL(iPos, *iText);
	return KErrNone;
	}

TBool CEditorCommandInsertPlainTextProto::PrepareToAddInverseToLastL(
	CSingleCommand& aLastCommand) const
	{
	if (aLastCommand.FamilyUid() != TUid::Uid(KUndoDllUid))
		return EFalse;
	CEditorCommandDeletePlainText* last =
		static_cast<CEditorCommand&>(aLastCommand).CastToCEditorCommandDeletePlainText();
	if (!last)
		return EFalse;
	return last->CanAdd(iPos, iText->Length(), iTarget);
	}

void CEditorCommandInsertPlainTextProto::AddInverseToLast(CSingleCommand& aLastCommand) const
	{
	ASSERT(aLastCommand.FamilyUid() == TUid::Uid(KUndoDllUid));
	CEditorCommandDeletePlainText* last =
		static_cast<CEditorCommand&>(aLastCommand).CastToCEditorCommandDeletePlainText();
	ASSERT(last);
	last->Add(iText->Length());
	}

//////////////////////////////////////////
//										//
//	CEditorCommandDeletePlainTextProto  //
//										//
//////////////////////////////////////////

void CEditorCommandDeletePlainTextProto::Set(TInt aPos, TInt aLength)
	{
	iPos = aPos;
	iLength = aLength;
	}

CCommand* CEditorCommandDeletePlainTextProto::CreateInverseL() const
	{
	return CEditorCommandInsertPlainText::NewBatchL(iPos, iLength, iTarget);
	}

TInt CEditorCommandDeletePlainTextProto::ExecuteL() const
	{
	iTarget.DeleteTextL(iPos, iLength);
	return KErrNone;
	}

TBool CEditorCommandDeletePlainTextProto::PrepareToAddInverseToLastL(
	CSingleCommand& aLastCommand) const
	{
	if (iDeletedText.MaxLength() < iLength)
		return EFalse;
	if (aLastCommand.FamilyUid() != TUid::Uid(KUndoDllUid))
		return EFalse;
	CEditorCommandInsertPlainText* last =
		static_cast<CEditorCommand&>(aLastCommand).CastToCEditorCommandInsertPlainText();
	if (!last)
		return EFalse;
	TBool result = EFalse;
	TPtrC textSegment;
	iTarget.GetText(iPos, textSegment);
	if (iLength <= textSegment.Length())
		{
		result = last->CanAdd(iPos, textSegment.Left(iLength), iTarget);
		if (result)
			iDeletedText = textSegment.Left(iLength);
		}
	return result;
	}

void CEditorCommandDeletePlainTextProto::AddInverseToLast(CSingleCommand& aLastCommand) const
	{
	ASSERT(aLastCommand.FamilyUid() == TUid::Uid(KUndoDllUid));
	CEditorCommandInsertPlainText* last =
		static_cast<CEditorCommand&>(aLastCommand).CastToCEditorCommandInsertPlainText();
	ASSERT(last);
	last->Add(iPos, iDeletedText);
	}

//////////////////////////////////
//								//
//	TEditorInsertPlainTextImpl  //
//								//
//////////////////////////////////

TInt TEditorInsertPlainTextImpl::ExecuteL(const TDesC* aStyle,
	const TTmCharFormatLayer* aChar,
	const RTmParFormatLayer* aPar) const
	{
	iTarget.InsertTextL(iPos, iText, aStyle, aChar, aPar);
	return KErrNone;
	}

TInt TEditorInsertPlainTextImpl::ExecuteL() const
	{
	return ExecuteL(0, 0, 0);
	}

TInt TEditorInsertPlainTextImpl::CanAdd(TInt aPos, const TDesC& aText, MUnifiedEditor& aTarget) const
	{
	if (&aTarget != &iTarget)
		return EFalse;
	TInt length = aText.Length();
	if (KMaxCharsInSingleCommand <= iText.Length() + length)
		return EFalse;
	return aPos <= iPos && iPos <= aPos + length;
	}

void TEditorInsertPlainTextImpl::Add(TInt aPos, const TDesC& aText)
	{
	TPtrC left = aText.Left(iPos - aPos);
	TPtrC right = aText.Mid(iPos - aPos);
	iText.Insert(0, left);
	iText.Append(right);
	iPos = aPos;
	}

//////////////////////////////////
//								//
//	TEditorDeletePlainTextImpl  //
//								//
//////////////////////////////////

TInt TEditorDeletePlainTextImpl::ExecuteL() const
	{
	iTarget.DeleteTextL(iPos, iLength);
	return KErrNone;
	}

TBool TEditorDeletePlainTextImpl::CanAdd(TInt aPos, TInt aLength, MUnifiedEditor& aTarget) const
	{
	return &aTarget == &iTarget && iPos <= aPos && aPos <= iLength + iPos
		&& aLength + iLength <= KMaxCharsInSingleCommand;
	}

void TEditorDeletePlainTextImpl::Add(TInt aLength)
	{
	iLength += aLength;
	}

/////////////////////////////
//						   //
//  TEditorPasteProtoImpl  //
//						   //
/////////////////////////////

void TEditorPasteProtoImpl::Set(const CStreamStore& aStore,
								const CStreamDictionary& aDict,
								TInt aPos)
	{
	iStore = &aStore;
	iStreamDictionary = &aDict;
	iPos = aPos;
	}

void TEditorPasteProtoImpl::OpenPlainTextStreamLC(RStoreReadStream& aStream) const
	{
	TStreamId plainTextStream = iStreamDictionary->At(KClipboardUidTypePlainText);
	if (plainTextStream == KNullStreamId)
		User::Leave(KErrNotSupported);		// don't know how to undo this
	aStream.OpenLC(*iStore, plainTextStream);
	}

TInt TEditorPasteProtoImpl::LengthL() const
	{
	RStoreReadStream stream;
	OpenPlainTextStreamLC(stream);
	TInt length = stream.ReadInt32L();
	CleanupStack::PopAndDestroy();
	return length;
	}

TInt TEditorPasteProtoImpl::ExecuteL() const
	{
	MUnifiedEditor::MClipboardSupport* ci = iTarget.ClipboardSupport();
	ASSERT(ci);
	ci->PasteFromStoreL(*iStore, *iStreamDictionary, iPos);
	return KErrNone;
	}

/////////////////////////////////////////
//									   //
//	CEditorCommandPastePlainTextProto  //
//									   //
/////////////////////////////////////////

void CEditorCommandPastePlainTextProto::Set(const CStreamStore& aStore,
	const CStreamDictionary& aStreamDictionary,
	TInt aPos)
	{
	iImpl.Set(aStore, aStreamDictionary, aPos);
	}

UndoSystem::CCommand* CEditorCommandPastePlainTextProto::CreateInverseL() const
	{
	return CEditorCommandDeletePlainText::NewL(iImpl.Pos(), iImpl.LengthL(), iImpl.Target());
	}

TInt CEditorCommandPastePlainTextProto::ExecuteL() const
	{
	return iImpl.ExecuteL();
	}