/*

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

#include "AssertFileAndLine.h"

using namespace UndoSystem;

namespace UndoSystemImpl

{

const TInt KCommandStackGranularity = 10;

_LIT(KUndoPanic, "Undo System");

}

using namespace UndoSystemImpl;

void UndoSystem::Panic(TPanicCode aCode)

	{

	User::Panic(KUndoPanic, aCode);

	}

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

//				   //

//	CCommandStack  //

//				   //

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

CCommandStack::CCommandStack() : iEnd(0), iBookmark(0) {}

CCommandStack::~CCommandStack()

	{

	if (iStack)

		{

		Reset();

		delete iStack;

		}

	}

void CCommandStack::ConstructL()

	{

	iStack = new(ELeave) CArrayFixSeg<CCommand*>(KCommandStackGranularity);

	}

CCommandStack* CCommandStack::NewL()

	{

	CCommandStack* r = new(ELeave) CCommandStack();

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop(r);

	return r;

	}

TInt CCommandStack::Count() const

	{

	ASSERT(iEnd <= iStack->Count());

	return iEnd;

	}

void CCommandStack::Reset()

	{

	PruneTo(0);

	iBookmark = -1;

	}

CCommand* CCommandStack::Top() const

	{

	ASSERT(0 <= iEnd);

	ASSERT(iEnd <= iStack->Count());

	return iEnd == 0? 0 : iStack->At(iEnd - 1);

	}

CCommand* CCommandStack::Pop()

	{

	ASSERT(iEnd <= iStack->Count());

	CCommand* top = Top();

	__ASSERT_ALWAYS(top, UndoSystem::Panic(KCommandStackUnderflow));

	TInt numSlots = iStack->Count() - iEnd + 1;

	ASSERT(numSlots <= iStack->Count());

	iStack->Delete(iStack->Count() - numSlots, numSlots);

	iEnd = iStack->Count();

	if (iEnd < iBookmark)

		iBookmark = -1;

	return top;

	}

void CCommandStack::PruneTo(TInt aNumberOfItems)

	{

	ASSERT(iEnd <= iStack->Count());

	iStack->Delete(iEnd, iStack->Count() - iEnd);

	iEnd = iStack->Count();

	if (aNumberOfItems < iEnd)

		{

		TInt numberToDestroy = iEnd - aNumberOfItems;

		for (TInt i = 0; i != numberToDestroy; ++i)

			{

			delete iStack->At(i);

			}

		iStack->Delete(0, numberToDestroy);

		iStack->Compress();

		iEnd = aNumberOfItems;

		iBookmark -= aNumberOfItems;

		}

	}

void CCommandStack::PrepareToPushL(TInt aNumberOfItems)

	{

	iStack->ResizeL(iEnd + aNumberOfItems);

	}

void CCommandStack::Push(CCommand* aCommand)

	{

	ASSERT(aCommand);

	__ASSERT_ALWAYS(iEnd < iStack->Count(), UndoSystem::Panic(KCommandStackPushNotPrepared));

	iStack->At(iEnd) = aCommand;

	++iEnd;

	}

void CCommandStack::Concatenate(CCommandStack& aStack)

	{

	TInt thisCount = iEnd;

	iEnd += aStack.iEnd;

	__ASSERT_DEBUG(iEnd <= iStack->Count(),

		UndoSystem::Panic(KCommandStackPushNotPrepared));

	for (TInt i = 0; i != aStack.iEnd; ++i, ++thisCount)

		iStack->At(thisCount) = (aStack.iStack->At(i));

	aStack.iEnd = 0;

	aStack.iStack->Reset();

	}

void CCommandStack::SetBookmark()

	{

	iBookmark = iEnd;

	}

TBool CCommandStack::IsAtBookmark() const

	{

	return iBookmark == iEnd? ETrue : EFalse;

	}

CSingleCommandStack* CSingleCommandStack::NewL()

	{

	CSingleCommandStack* r = new(ELeave) CSingleCommandStack;

	CleanupStack::PushL(r);

	r->iStack.ConstructL();

	CleanupStack::Pop(r);

	return r;

	}

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

//					 //

//	CCommandHistory  //

//					 //

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

CCommandHistory::CCommandHistory()

	: iMaxItems(KMaxTInt >> 1)

	{

	}

CCommandHistory::~CCommandHistory()

	{

	delete iStack;

	}

void CCommandHistory::ConstructL()

	{

	iStack = CCommandStack::NewL();

	iCurrent = 0;

	}

CCommandHistory* CCommandHistory::NewL()

	{

	CCommandHistory* r = new(ELeave) CCommandHistory();

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop(r);

	return r;

	}

void CCommandHistory::Prune()

	{

	if (iMaxItems < iStack->Count())

		iStack->PruneTo(iMaxItems);

	}

void CCommandHistory::SetMaxItems(TInt aMaxItems)

	{

	ASSERT(0 < aMaxItems);

	iMaxItems = aMaxItems;

	Prune();

	}

void CCommandHistory::CloseBatch(void* a)

	{

	CCommandHistory* aThat = reinterpret_cast<CCommandHistory*>(a);

	aThat->iCurrent = 0;

	if (aThat->iBatchUndoHasBeenWaived)

		aThat->Reset();

	}

void CCommandHistory::DownBatchLevel(void*) {}

TBool CCommandHistory::IsWithinBatch() const

	{

	return iCurrent? ETrue : EFalse;

	}

void CCommandHistory::BeginBatchLC()

	{

	if (iCurrent)

		{

		CleanupStack::PushL(TCleanupItem(DownBatchLevel, this));

		}

	else

		{

		iStack->PrepareToPushL(1);

		iBatchUndoHasBeenWaived = EFalse;

		CleanupStack::PushL(TCleanupItem(CloseBatch, this));

		CBatchCommand* batch = CBatchCommand::NewL();

		iCurrent = batch;

		iStack->Push(batch);

		}

	}

TBool CCommandHistory::UndoHasBeenWaived() const

	{

	return iCurrent? iBatchUndoHasBeenWaived : EFalse;

	}

void CCommandHistory::SetUndoWaived()

	{

	iBatchUndoHasBeenWaived = ETrue;

	}

void CCommandHistory::Reset()

	{

	iStack->Reset();

	iCurrent = 0;

	}

void CCommandHistory::PrepareToAddCommandL(CCommand* aCommand)

	{

	if (iCurrent)

		iCurrent->PrepareToPushL(aCommand);

	else

		iStack->PrepareToPushL(1);

	}

void CCommandHistory::AddCommand(CCommand* aCommand)

	{

	if (iCurrent)

		iCurrent->Push(aCommand);

	else

		iStack->Push(aCommand);

	if (!iCurrent)

		Prune();

	}

CSingleCommand* CCommandHistory::TopSingleCommand() const

	{

	CCommand* top = Top();

	if (!top)

		return 0;

	// if the top of the undo stack is an empty batch, then we are starting a new

	// batch command and so do not want to combine. Otherwise, if the top is a batch

	// with elements, we want to see if we can combine with the top one.

	CBatchCommand* batch = top->Batch();

	return batch? batch->Top() : top->Single();

	}

CCommand* CCommandHistory::Top() const

	{

	return iStack->Top();

	}

CCommand* CCommandHistory::Pop()

	{

	ASSERT(!iCurrent);

	return iStack->Pop();

	}

void CCommandHistory::Clean()

	{

	ASSERT(!iCurrent);

	CCommand* command = Top();

	if (!command)

		return;

	CBatchCommand* batch = command->Batch();

	if (!batch)

		return;

	if (batch->IsEmpty())

		{

		delete Pop();

		}

	}

void CCommandHistory::SetBookmark()

	{

	iStack->SetBookmark();

	}

TBool CCommandHistory::IsAtBookmark()

	{

	return iStack->IsAtBookmark();

	}