/*

* 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 "EditorCommands.h"

#include "AssertFileAndLine.h"

#include <txtetext.h>

#include <s32ucmp.h>

using namespace UndoSystem;

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;

	}

// These roughly mirror the prototype commands, but rather than

// referencing externally-owned (and therefore temporary) objects,

// they own objects. Typically these are unique instances.

/**

 * Command for setting the base character and paragraph formats.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandSetBaseFormat) : public CEditorCommand

	{

	MUnifiedEditor&						iTarget;

	RUniqueInstance<TTmCharFormat>	iChar;

	RUniqueInstance<RTmParFormat>	iPar;

	const TRepositories& iRepositories;

	CEditorCommandSetBaseFormat(const TRepositories& aReps, MUnifiedEditor& aTarget);

public:

	~CEditorCommandSetBaseFormat();

	static CEditorCommandSetBaseFormat* NewL(const TRepositories& aReps,

		const TTmCharFormat& aCharFormat, const RTmParFormat& aParFormat,

		MUnifiedEditor& aTarget);

	static CEditorCommandSetBaseFormat* NewL(const TRepositories& aReps,

		MUnifiedEditor& aTarget);

	UndoSystem::CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for renaming a style.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandRenameStyle) : public CEditorCommand

	{

	MUnifiedEditor&				iTarget;

	RUniqueInstance<TDes>	iOldName;

	RUniqueInstance<TDes>	iNewName;

	const TRepositories& iRepositories;

	CEditorCommandRenameStyle(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iOldName(*aReps.iDes), iNewName(*aReps.iDes),

		iRepositories(aReps) {}

public:

	~CEditorCommandRenameStyle();

	static CEditorCommandRenameStyle* NewL(const TRepositories& aReps,

		const TDesC& aOldName, const TDesC& aNewName, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for inserting a picture into the text.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandInsertPicture) : public CEditorCommand

	{

	MUnifiedEditor&				iTarget;

	TInt					iPos;

	mutable TPictureHeader	iPicture;

	MPictureOwner*			iPictureOwner;

	const TRepositories&	iRepositories;

	CEditorCommandInsertPicture(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iRepositories(aReps) {}

public:

	~CEditorCommandInsertPicture();

	static CEditorCommandInsertPicture* NewL(const TRepositories& aReps,

		TInt aPos, MPictureOwner& aPictureOwner, MUnifiedEditor& aTarget);

	void TakePictureOwnership(TPictureHeader&);

	void ForgetOwner(MPictureOwner*);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for creating a new style.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandCreateStyle) : public CEditorCommand

	{

	MUnifiedEditor&					iTarget;

	RUniqueInstance<TDes>			iName;

	RUniqueInstance<TDes>			iNext;

	RUniqueInstance<TTmCharFormat>	iChar;

	TTmCharFormatMask				iCharMask;

	RUniqueInstance<RTmParFormat>	iPar;

	TTmParFormatMask				iParMask;

	TInt							iLevel;

	const TRepositories& iRepositories;

	CEditorCommandCreateStyle(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iName(*aReps.iDes), iNext(*aReps.iDes),

		iChar(*aReps.iChar),

		iPar(*aReps.iPar), iRepositories(aReps) {}

public:

	~CEditorCommandCreateStyle();

	static CEditorCommandCreateStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, const TDesC& aNext,

		TTmCharFormat& aChar, TTmCharFormatMask aCharMask,

		RTmParFormat& aPar, TTmParFormatMask aParMask,

		TInt aLevel, MUnifiedEditor& aTarget);

	static CEditorCommandCreateStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, MUnifiedEditor& aTarget);

	static CCommand* NewBatchL(const TRepositories& aReps,

		const TDesC& aName, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for deleting a style, removing it from anywhere that it is applied.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandDeleteStyle) : public CEditorCommand

	{

	MUnifiedEditor&						iTarget;

	RUniqueInstance<TDes>				iName;

	const TRepositories& iRepositories;

	CEditorCommandDeleteStyle(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iName(*aReps.iDes), iRepositories(aReps) {}

public:

	~CEditorCommandDeleteStyle();

	static CEditorCommandDeleteStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for altering the attributes of a style.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandAlterStyle) : public CEditorCommand

	{

	MUnifiedEditor&					iTarget;

	RUniqueInstance<TDes>			iName;

	RUniqueInstance<TDes>			iNext;

	RUniqueInstance<TTmCharFormat>	iChar;

	TTmCharFormatMask				iCharMask;

	RUniqueInstance<RTmParFormat>	iPar;

	TTmParFormatMask				iParMask;

	TInt							iLevel;

	const TRepositories& iRepositories;

	CEditorCommandAlterStyle(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iName(*aReps.iDes), iNext(*aReps.iDes),

		iChar(*aReps.iChar), iPar(*aReps.iPar), iRepositories(aReps) {}

public:

	~CEditorCommandAlterStyle();

	static CEditorCommandAlterStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, const TDesC& aNext,

		TTmCharFormat& aChar, TTmCharFormatMask& aCharMask,

		RTmParFormat& aPar, TTmParFormatMask& aParMask,

		TInt aLevel, MUnifiedEditor& aTarget);

	static CEditorCommandAlterStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for applying an existing style to text.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandSetStyle) : public CEditorCommand

	{

	MUnifiedEditor&			iTarget;

	RUniqueInstance<TDes>	iName;

	TInt					iPos;

	TInt					iRunLength;

	const TRepositories& iRepositories;

	CEditorCommandSetStyle(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iName(*aReps.iDes), iRepositories(aReps) {}

public:

	~CEditorCommandSetStyle();

	static CEditorCommandSetStyle* NewL(const TRepositories& aReps,

		const TDesC& aName, TInt aPos, TInt aRunLength,

		MUnifiedEditor& aTarget);

	static CCommand* NewL(const TRepositories& aReps,

		TInt aPos, TInt aRunLength,

		MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for deleting text without pictures in it.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandDeleteText) : public CEditorCommand

	{

	TEditorDeletePlainTextImpl iImpl;

	const TRepositories& iRepositories;		// only used in creating the inverse

	CEditorCommandDeleteText*

		CastToCEditorCommandDeleteText() { return this; }

	CEditorCommandDeleteText(const TRepositories& aReps, MUnifiedEditor& aTarget,

		TInt aPos, TInt aLength)

		: iImpl(aTarget, aPos, aLength), iRepositories(aReps) {}

public:

	~CEditorCommandDeleteText();

	static CEditorCommandDeleteText* NewL(const TRepositories& aReps,

		TInt aPos, TInt aLength, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	// This command can be coalesced with others of the same type

	TBool CanAdd(TInt aPos, TInt aLength, MUnifiedEditor& aTarget) const;

	void Add(TInt aLength);

	};

/**

 * Command for inserting text in a specified style and format.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandInsertTextAndFormat) : public CEditorCommand

	{

	TEditorInsertPlainTextImpl		iImpl;

	// layer

	RUniqueInstance<TTmCharFormat>	iChar;

	TTmCharFormatMask				iCharMask;

	RUniqueInstance<RTmParFormat>	iPar;

	TTmParFormatMask				iParMask;

	RUniqueInstance<TDes>			iStyle;

	const TRepositories& iRepositories;

	CEditorCommandInsertTextAndFormat*

		CastToCEditorCommandInsertTextAndFormat() { return this; }

	CEditorCommandInsertTextAndFormat(const TRepositories& aReps,

		MUnifiedEditor& aTarget, TInt aPos, TDesC& aText)

		: iImpl(aTarget, aPos, aText), iChar(*aReps.iChar), iPar(*aReps.iPar),

		iStyle(*aReps.iDes), iRepositories(aReps) {}

public:

	struct RTextAndFormatParameters

		{

		TInt				iPos;

		TPtrC				iText;

		TPtrC				iStyleName;

		TTmCharFormatLayer	iChar;

		RTmParFormatLayer	iPar;

		void Close();

		void SetL(TInt aPos, TInt aMaxLength, MUnifiedEditor& aTarget);

		};

	~CEditorCommandInsertTextAndFormat();

	static CEditorCommandInsertTextAndFormat* NewL(const TRepositories& aReps,

		RTextAndFormatParameters& aParams, MUnifiedEditor& aTarget);

	/**

	 * Gets as much of a run as possible.

	 */

	static CEditorCommandInsertTextAndFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt& aRemaining, TInt aOriginalPos, MUnifiedEditor& aTarget);

	/**

	 * Gets as many runs as necessary and returns a batch if necessary.

	 */

	static CCommand* NewBatchL(const TRepositories& aReps,

		TInt aPos, TInt aLength, MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	// This command can be coalesced with others of the same type

	TBool CanAdd(const RTextAndFormatParameters&, MUnifiedEditor& aTarget) const;

	void Add(TInt aPos, const TDesC& aText);

	};

/**

 * Command for deleting the specific character format over a run of text.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandDeleteCharFormat) : public CEditorCommand

	{

	MUnifiedEditor&	iTarget;

	TInt		iPos;

	TInt		iLength;

	const TRepositories& iRepositories;

	CEditorCommandDeleteCharFormat*

		CastToCEditorCommandDeleteCharFormat() { return this; }

	CEditorCommandDeleteCharFormat(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iRepositories(aReps) {}

public:

	~CEditorCommandDeleteCharFormat();

	static CEditorCommandDeleteCharFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt aLength,

		MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	// This command can be coalesced with others of the same type

	TBool CanAdd(TInt aPos, TInt aLength, MUnifiedEditor& aTarget) const;

	void Add(TInt aPos, TInt aLength);

	};

/**

 * Command for deleting the specific paragraph format over a run of text.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandDeleteParFormat) : public CEditorCommand

	{

	MUnifiedEditor&	iTarget;

	TInt		iPos;

	TInt		iLength;

	const TRepositories& iRepositories;

	CEditorCommandDeleteParFormat*

		CastToCEditorCommandDeleteParFormat() { return this; }

	CEditorCommandDeleteParFormat(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iRepositories(aReps) {}

public:

	~CEditorCommandDeleteParFormat();

	static CEditorCommandDeleteParFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt aLength,

		MUnifiedEditor& aTarget);

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	// This command can be coalesced with others of the same type

	TBool CanAdd(TInt aPos, TInt aLength, MUnifiedEditor& aTarget) const;

	void Add(TInt aPos, TInt aLength);

	};

/**

 * Command for applying a character format to a run of text that has no

 * existing specific character format.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandSetCharFormat) : public CEditorCommand

	{

	MUnifiedEditor&						iTarget;

	TInt							iPos;

	TInt							iLength;

	// layer

	RUniqueInstance<TTmCharFormat>	iChar;

	TTmCharFormatMask				iCharMask;

	const TRepositories& iRepositories;

	CEditorCommandSetCharFormat(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iChar(*aReps.iChar), iRepositories(aReps) {}

public:

	~CEditorCommandSetCharFormat();

	static CEditorCommandSetCharFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt aLength,

		const TTmCharFormat* aChar, TTmCharFormatMask aCharMask,

		MUnifiedEditor& aTarget);

	// get as much of a run as possible.

	static CEditorCommandSetCharFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt& aRemaining, MUnifiedEditor& aTarget);

	// get as many runs as necessary and return a batch if necessary.

	static CCommand* NewBatchL(const TRepositories& aReps,

		TInt aPos, TInt aLength, MUnifiedEditor& aTarget);

	TBool PrepareToAddInverseToLastL(CSingleCommand& aLastCommand) const;

	void AddInverseToLast(CSingleCommand& aLastCommand) const;

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for applying a paragraph format to a run of text that has no

 * existing specific paragraph format.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandSetParFormat) : public CEditorCommand

	{

	MUnifiedEditor&					iTarget;

	TInt							iPos;

	TInt							iLength;

	// layer

	RUniqueInstance<RTmParFormat>	iPar;

	TTmParFormatMask				iParMask;

	const TRepositories& iRepositories;

	CEditorCommandSetParFormat(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iPar(*aReps.iPar), iRepositories(aReps) {}

public:

	~CEditorCommandSetParFormat();

	static CEditorCommandSetParFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt aLength,

		const RTmParFormat* aFormat, TTmParFormatMask aMask,

		MUnifiedEditor& aTarget);

	// get as much of a run as possible.

	static CEditorCommandSetParFormat* NewL(const TRepositories& aReps,

		TInt aPos, TInt& aRemaining, MUnifiedEditor& aTarget);

	// get as many runs as necessary and return a batch if necessary.

	static CCommand* NewBatchL(const TRepositories& aReps,

		TInt aPos, TInt aLength, MUnifiedEditor& aTarget);

	TBool PrepareToAddInverseToLastL(CSingleCommand& aLastCommand) const;

	void AddInverseToLast(CSingleCommand& aLastCommand) const;

	CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

/**

 * Command for deleting a picture from the text. The picture is assumed

 * to be without significant formatting.

 *

 * @internalComponent

 * @since App-frameworks6.1

 */

NONSHARABLE_CLASS(CEditorCommandDeletePicture) : public CEditorCommand,

	private MPictureOwner

	{

	MUnifiedEditor&							iTarget;

	TInt									iPos;

	const TRepositories&					iRepositories;

	/**

	 * Will own picture after us.

	 */

	mutable CEditorCommandInsertPicture*	iPictureOwnerDelegate;

	void ForgetDelegate();

	CEditorCommandDeletePicture(const TRepositories& aReps, MUnifiedEditor& aTarget)

		: iTarget(aTarget), iRepositories(aReps) {}

public:

	~CEditorCommandDeletePicture();

	static CEditorCommandDeletePicture* NewL(const TRepositories& aReps,

		TInt aPos, MUnifiedEditor& aTarget);

	UndoSystem::CCommand* CreateInverseL() const;

	TInt ExecuteL() const;

	};

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

//								 //

//	CEditorCommandSetBaseFormat  //

//								 //

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

CEditorCommandSetBaseFormat::CEditorCommandSetBaseFormat(

	const TRepositories& aReps, MUnifiedEditor& aTarget)

	: iTarget(aTarget), iChar(*aReps.iChar), iPar(*aReps.iPar),

	iRepositories(aReps)

	{

	}

CEditorCommandSetBaseFormat::~CEditorCommandSetBaseFormat()

	{