/*

 * 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();

 	}