// Copyright (c) 2002-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 "LogViewWindow.h"

 // User includes

 #include "logclientop.h"

 #include "logclipanic.h"

 #include "LogViewWindowChangeObserver.h"

 // Constants

 const TInt KWindowSlideSize = 2;

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

 // -----> CLogViewWindow (source)

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

 CLogViewWindow::CLogViewWindow(RLogSession& aSession, TLogViewId aViewId, TInt aWindowSize, MLogViewChangeObserver* aCascadeObserver, TInt aPriority)

 :	CLogActive(aPriority), iSession(aSession), iViewId(aViewId), iWindowSize(aWindowSize), iCascadeObserver(aCascadeObserver), iEvents(aWindowSize)

 	{

 	Reset();

 	}

 CLogViewWindow::~CLogViewWindow()

 	{

 	Cancel();

 	//

 	delete iWindowChangeObserver;

 	delete iWindowPreparer;

 	delete iWindowFetcher;

 	delete iWindowLockObserver;

 	//

 	iEvents.ResetAndDestroy();

 	iEvents.Close();

 	}

 void CLogViewWindow::ConstructL(CLogPackage& aPackage)

 	{

 	iWindowPreparer = new(ELeave) CLogViewSetupClientOp(iSession, aPackage, CActive::EPriorityStandard);

 	//

 	iWindowFetcher = new(ELeave) CLogViewWindowFetcher(iSession, iViewId, *this, CActive::EPriorityIdle + 1);

 	iWindowFetcher->ConstructL();

 	//

 	iWindowLockObserver = new(ELeave) CLogViewWindowLockObserver(iSession, iViewId, *this, CActive::EPriorityHigh);

 	iWindowLockObserver->ConstructL();

 	//

 	iWindowChangeObserver = new(ELeave) CLogViewWindowChangeObserver(*this);

 	}

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

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

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

 TInt CLogViewWindow::Setup(const CLogFilterList& aFilterList, TInt aParam, TLogFilterConstructionType aFilterConstructionType)

 	{

 	Reset();

 	iViewRecordCount = iWindowPreparer->Start(iViewId, aFilterList, aParam, aFilterConstructionType);

 	return iViewRecordCount;

 	}

 TBool CLogViewWindow::NavigateL(TLogNavigation aNavigate, TRequestStatus& aStatus)

 	{

 	// Check why we're already active

 	switch(iState)

 		{

 	case EStateIdle:

 	case EStateLocked:

 		__ASSERT_DEBUG(!IsActive(), Panic(ELogWindowStateMachineNavigationError1));

 		break;

 	case EStateFetchingWindow:

 	case EStateProcessingWindow:

 	case EStateNavigateWithinWindow:

 		// We're trying to catch up with some changes.. use the requested

 		// window as the new window, but refetch everything.

 		__ASSERT_DEBUG(IsActive(), Panic(ELogWindowStateMachineNavigationError2));

 		SilentCancel();

 		iWindow = iWindowFetcher->RequestedWindow();

 		break;

 	default:

 		break;

 		}

 	// Perform boundary checks

 	TInt cursorPos = CalculateCursorPosition(aNavigate);

 	if	(cursorPos < 0 || cursorPos >= iViewRecordCount)

 		{

 		// Can't navigate to the specified position

 		return EFalse;

 		}

 	// Check whether the cursor position falls within the view window 

 	if	(iWindow.iValid && iWindow.Contains(cursorPos))

 		{

 		// Can return event from window

 		CompleteRequest(cursorPos);

 		ChangeState(EStateNavigateWithinWindow);

 		}

 	else

 		{

 		// Have to fetch a new window. Work it out...

 		TLogWindowAndCursor window;

 		CalculateWindowForCursorPosition(cursorPos, window);

 		window.iCursorPosition = cursorPos;

 		iWindowFetcher->PrepareToFetchWindowL(window);

 		//		

 		CompleteRequest(KErrNone);

 		ChangeState(EStateFetchingWindow);

 		}

 	// Okay to (try to) navigate here

 	Queue(aStatus);

 	return ETrue;

 	}

 void CLogViewWindow::RemoveFromWindowIfPresentL(TLogId aId)

 	{

 	TInt index = FindEvent(aId);

 	if	(index >= 0)

 		{

 		// Ignore next window removal event (since we're proactively removing

 		// the event from the client side without server prompting).

 		iWindowChangeObserver->IgnoreNextEventL(aId, CLogViewWindowChangeObserver::ELogEventTypeDelete);

 		// Delete item	

 		RemoveEvent(index);

 		// Map onto full view position

 		index += iWindow.iLower;

 		// Update window - when removing the last event from the window, we must

 		// ensure we mark the window as invalid.

 		if	(iWindow.AdjustForItemDeletion(index) == TLogWindowAndCursor::EWindowAffected && iEvents.Count() == 0)

 			{

 			iWindow.Reset();

 			}

 		}

 	//

 	--iViewRecordCount;

 	}

 MLogViewChangeObserverInternal& CLogViewWindow::ChangeObserver()

 	{

 	__ASSERT_ALWAYS(iWindowChangeObserver, Panic(ELogWindowNoChangeObserver));

 	return *iWindowChangeObserver;

 	}

 const CLogEvent& CLogViewWindow::CurrsorEvent() const

 	{

 	// Map the cursor position to fall within the window

 	const TInt mappedIndex = iWindow.WindowIndexFromCursorPosition();

 	const TInt count = iEvents.Count();

 	__ASSERT_ALWAYS(mappedIndex >= 0 && mappedIndex < count, Panic(ELogWindowCursorCalculationOutOfBounds));

 	return *iEvents[mappedIndex];

 	}

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

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

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

 void CLogViewWindow::HandleWindowLockStatusChangeL(TLogViewLockStatus aStatus)

 	{

 	switch(aStatus)

 		{

 	case ELogViewWindowLocked:

 		SilentCancel();

 		iState = EStateLocked;

 		break;

 	case ELogViewWindowOpen:

 		if (iState == EStateLocked)

 			iState = EStateIdle; 

 		break;

 	default:

 		break;

 		}

 	// The window is never valid after a change in lock status

 	iWindow.iValid = EFalse;

 	}

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

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

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

 void CLogViewWindow::HandleFetchedWindowItemL(TInt /*aItemIndex*/, CLogEvent* aEvent)

 	{

 	// IMPROVEMENT: could use aItemIndex as the insertion point?

 	User::LeaveIfError(iEvents.Append(aEvent));

 	}

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

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

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

 void CLogViewWindow::HandleLogViewChangeEventAddedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

 	{

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

 	// USE CASE 1:

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

 	// Cursor position:  *

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item X is added => 

 	// 

 	// Cursor position:    *

 	// View Index:       0 1 2 3 4 5 6 7

 	// View Contents:    X A B C D E F G

 	// 

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

 	// USE CASE 2:

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

 	// Cursor position:              *

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item X is added => 

 	// 

 	// Cursor position:                *

 	// View Index:       0 1 2 3 4 5 6 7

 	// View Contents:    X A B C D E F G

 	// 

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

 	// USE CASE 3:

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

 	// Cursor position:    *          

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item X is added => 

 	// 

 	// Cursor position:      *          

 	// View Index:       0 1 2 3 4 5 6 7

 	// View Contents:    X A B C D E F G

 	// 

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

 	// USE CASE 4:

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

 	// Cursor position:    *          

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, change item Z so that it now appears in the view

 	// 

 	// Cursor position:    *          

 	// View Index:       0 1 2 3 4 5 6 7

 	// View Contents:    A B C Z D E F G

 	// 

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

 	// USE CASE 5:

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

 	// Cursor position:        *      

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, change item Z so that it now appears in the view

 	// 

 	// Cursor position:          *   

 	// View Index:       0 1 2 3 4 5 6 7

 	// View Contents:    A B C Z D E F G

 	// 

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

 	//RDebug::Print(_L("CLogViewWindow::HandleLogViewChangeEventAddedL()   - aId: %3d, aViewIndex: %3d, aChangeIndex: %3d, aTotalChangeCount: %d, cursorPos: %3d, window: (%3d, %3d), viewCount: %3d, iState: %d"), aId, aViewIndex, aChangeIndex, aTotalChangeCount, iWindow.iCursorPosition, iWindow.iLower, iWindow.iUpper, iViewRecordCount, iState);

 	// Must compare against the current window (if this object is idle) or against

 	// the window fetcher's window if it is in the process of making a fetch

 	TLogWindowAndCursor currentWindow;

 	switch(iState)

 		{

 	case EStateFetchingWindow:

 	case EStateProcessingWindow:

 		currentWindow = iWindowFetcher->RequestedWindow();

 		break;

 	case EStateNavigateWithinWindow:

 	case EStateIdle:

 	case EStateLocked:

 		currentWindow = iWindow;

 		break;

 		}

 	// If the addition took place after the window, then we do nothing (except update the

 	// total view record count)

 	if	(aViewIndex <= currentWindow.iUpper)

 		{

 		// If the addition took place before our window, or at the very start, then we simply need to adjust 

 		// the window & cursor position. If the window fetcher was active then this will affect the window

 		// being fetched - in this case, we MUST refetch the whole window.

 		if	(iState == EStateIdle && aViewIndex <= currentWindow.iLower)

 			{

 			iWindow.AdjustForItemAddition(aViewIndex);

 			}

 		else

 			{

 			// If the addition took place within the window, then we have to refetch the window

 			TBool refetch = ETrue;

 			TLogWindowAndCursor newWindow;

 			//

 			switch(iState)

 				{

 			case EStateIdle:

 				newWindow = iWindow;

 				break;

 			case EStateNavigateWithinWindow:

 				// Since we complete our own request status with the new cursor position, 

 				// we can use that here as the desired cursor position after the fetch

 				newWindow = iWindow;

 				newWindow.iCursorPosition = iStatus.Int();

 				break;

 			case EStateFetchingWindow:

 			case EStateProcessingWindow:

 				newWindow = iWindowFetcher->RequestedWindow();

 				break;

 			case EStateLocked:

 				// Don't need to do anything. When the view is unlocked, we refetch anyway

 				refetch = EFalse;

 				break;

 			default:

 				break;

 				}

 			//

 			if	(refetch)

 				{

 				newWindow.AdjustForItemAddition(aViewIndex);

 				RefetchL(newWindow, newWindow.iCursorPosition);

 				}

 			}

 		}

 	// Increase the total view size

 	++iViewRecordCount;

 	if	(iCascadeObserver)

 		iCascadeObserver->HandleLogViewChangeEventAddedL(aId, aViewIndex, aChangeIndex, aTotalChangeCount);

 	}

 void CLogViewWindow::HandleLogViewChangeEventChangedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

 	{

 	//RDebug::Print(_L("CLogViewWindow::HandleLogViewChangeEventChangedL() - aId: %3d, aViewIndex: %3d, aChangeIndex: %3d, aTotalChangeCount: %d, cursorPos: %3d, window: (%3d, %3d), viewCount: %3d, iState: %d"), aId, aViewIndex, aChangeIndex, aTotalChangeCount, iWindow.iCursorPosition, iWindow.iLower, iWindow.iUpper, iViewRecordCount, iState);

 	// Must compare against the current window (if this object is idle) or against

 	// the window fetcher's window if it is in the process of making a fetch

 	TLogWindowAndCursor currentWindow;

 	switch(iState)

 		{

 	case EStateFetchingWindow:

 	case EStateProcessingWindow:

 		currentWindow = iWindowFetcher->RequestedWindow();

 		break;

 	case EStateNavigateWithinWindow:

 	case EStateIdle:

 	case EStateLocked:

 		currentWindow = iWindow;

 		break;

 	default:

 		break;

 		}

 	// If the event that changed was within the view, then we have to refetch it

 	if	(currentWindow.Contains(aViewIndex))

 		{

 		switch(iState)

 			{

 		case EStateIdle:

 			RefetchL(iWindow, iWindow.iCursorPosition);

 			break;

 		case EStateNavigateWithinWindow:

 			// Since we complete our own request status with the new cursor position, 

 			// we can use that here as the desired cursor position after the fetch

 			RefetchL(iWindow, iStatus.Int());

 			break;

 		case EStateFetchingWindow:

 		case EStateProcessingWindow:

 			RefetchL(iWindowFetcher->RequestedWindow(), iWindowFetcher->RequestedWindow().iCursorPosition);

 			break;

 		case EStateLocked:

 			// Don't need to do anything. When the view is unlocked, we refetch anyway

 			break;

 		default:

 			break;

 			}

 		}

 	if	(iCascadeObserver)

 		iCascadeObserver->HandleLogViewChangeEventChangedL(aId, aViewIndex, aChangeIndex, aTotalChangeCount);

 	}

 void CLogViewWindow::HandleLogViewChangeEventDeletedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

 	{

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

 	// USE CASE 1:

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

 	// Cursor position:            *

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item 5 is deleted => 

 	// 

 	// Cursor position:            *

 	// View Index:       0 1 2 3 4 5

 	// View Contents:    A B C D E G

 	// 

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

 	// USE CASE 2:

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

 	// Cursor position:            *

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item 4 is deleted => 

 	// 

 	// Cursor position:          *

 	// View Index:       0 1 2 3 4 5

 	// View Contents:    A B C D F G

 	// 

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

 	// USE CASE 3:

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

 	// Cursor position:              *

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item 6 is deleted => 

 	// 

 	// Cursor position:            *

 	// View Index:       0 1 2 3 4 5

 	// View Contents:    A B C D E F

 	// 

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

 	// USE CASE 4:

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

 	// Cursor position:  *            

 	// View Index:       0 1 2 3 4 5 6

 	// View Contents:    A B C D E F G

 	//

 	// Then, item 6 is deleted => 

 	// 

 	// Cursor position:  *

 	// View Index:       0 1 2 3 4 5

 	// View Contents:    B C D E F G

 	// 

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

 	//RDebug::Print(_L("CLogViewWindow::HandleLogViewChangeEventDeletedL() - aId: %3d, aViewIndex: %3d, aChangeIndex: %3d, aTotalChangeCount: %d, cursorPos: %3d, window: (%3d, %3d), viewCount: %3d, iState: %d"), aId, aViewIndex, aChangeIndex, aTotalChangeCount, iWindow.iCursorPosition, iWindow.iLower, iWindow.iUpper, iViewRecordCount, iState);

 	// Must compare against the current window (if this object is idle) or against

 	// the window fetcher's window if it is in the process of making a fetch

 	TLogWindowAndCursor currentWindow;

 	switch(iState)

 		{

 	case EStateFetchingWindow:

 	case EStateProcessingWindow:

 		currentWindow = iWindowFetcher->RequestedWindow();

 		break;

 	case EStateNavigateWithinWindow:

 	case EStateIdle:

 	case EStateLocked:

 		currentWindow = iWindow;

 		break;

 	default:

 		break;

 		}

 	// Does the change alter our current window in any way?

 	if	(aViewIndex <= currentWindow.iUpper)

 		{

 		TBool refetch = ETrue;

 		TLogWindowAndCursor newWindow;

 		//

 		switch(iState)

 			{

 		case EStateIdle:

 			FindAndRemoveEvent(aId);

 			// When removing the last event from the window, we must ensure we mark

 			// the window as invalid.

 			if	(iWindow.AdjustForItemDeletion(aViewIndex) == TLogWindowAndCursor::EWindowAffected && iEvents.Count() == 0)

 				{

 				iWindow.Reset();

 				}

 			refetch = EFalse;

 			break;

 		case EStateNavigateWithinWindow:

 			newWindow = iWindow;

 			newWindow.iCursorPosition = iStatus.Int();

 			break;

 		case EStateFetchingWindow:

 		case EStateProcessingWindow:

 			newWindow = iWindowFetcher->RequestedWindow();

 			break;

 		case EStateLocked:

 			// Don't need to do anything. When the view is unlocked, we refetch anyway

 			refetch = EFalse;

 			break;

 		default:

 			break;

 			}

 		//

 		if	(refetch)

 			{

 			newWindow.AdjustForItemDeletion(aViewIndex);

 			RefetchL(newWindow, newWindow.iCursorPosition);

 			}

 		}

 	// Reduce the total view size

 	--iViewRecordCount;

 	if	(iCascadeObserver)

 		iCascadeObserver->HandleLogViewChangeEventDeletedL(aId, aViewIndex, aChangeIndex, aTotalChangeCount);

 	}

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

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

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

 void CLogViewWindow::HandleLogViewChangeEventLogClearedL()

 	{

 	Cancel();

 	Reset();

 	// This event type is not cascaded to the client of the log engine

 	}

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

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

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

 void CLogViewWindow::DoRunL()

 	{

 	switch(iState)

 		{

 	case EStateFetchingWindow:

 		StateHandleWindowFetchStarting();

 		break;

 	case EStateProcessingWindow:

 		StateHandleWindowFetchedL();

 		break;

 	case EStateNavigateWithinWindow:

 		StateHandleNavigation();

 		break;

 	case EStateIdle:

 	case EStateLocked:

 	default:

 		break;

 		}

 	}

 void CLogViewWindow::DoCancel()

 	{

 	if(iState == EStateProcessingWindow)

 		{

 		iWindowFetcher->Cancel();

 		}

 	CLogActive::DoCancel();

 	}

 void CLogViewWindow::DoComplete(TInt& aComplete)

 	{

 	switch(iState)

 		{

 	default:

 	case EStateIdle:

 		break;

 	case EStateNavigateWithinWindow:

 		if	(aComplete < KErrNone)

 			{

 			// Reset to known state

 			iState = EStateIdle;

 			}

 		break;

 	case EStateFetchingWindow:

 	case EStateProcessingWindow:

 		if	(aComplete < KErrNone)

 			{

 			// Reset to known state

 			iState = EStateIdle;

 			iWindow = iWindowFetcher->RequestedWindow();

 			}

 		break;

 	case EStateLocked:

 		aComplete = KErrAccessDenied;

 		break;

 		}

 	}

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

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

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

 void CLogViewWindow::StateHandleWindowFetchStarting()

 	{

 	iEvents.ResetAndDestroy();

 	iWindowFetcher->Start(iStatus);

 	ChangeState(EStateProcessingWindow);

 	SetActive();

 	}

 void CLogViewWindow::StateHandleWindowFetchedL()

 	{

 	const TInt count = iEvents.Count();

 	const TInt expected = iWindowFetcher->RequestedWindow().Range();

 	if	(expected != count)

 		User::Leave(KErrGeneral);

 	//	

 	iWindow = iWindowFetcher->RequestedWindow();

 	CompleteRequest(iWindow.iCursorPosition);

 	ChangeState(EStateNavigateWithinWindow);

 	}

 void CLogViewWindow::StateHandleNavigation()

 	{

 	const TInt cursorPos = iStatus.Int();

 	__ASSERT_ALWAYS(iWindow.Contains(cursorPos), Panic(ELogWindowNavigationOutsideWindow));

 	iWindow.iCursorPosition = cursorPos;

 	ChangeState(EStateIdle);

 	}

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

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

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

 void CLogViewWindow::CompleteRequest(TInt aCompletionCode)

 	{

 	if	(!IsActive() || (IsActive() && iStatus == KRequestPending))

 		{

 		TRequestStatus* status = &iStatus;

 		User::RequestComplete(status, aCompletionCode);

 		if	(!IsActive())

 			SetActive();

 		}

 	}

 void CLogViewWindow::CalculateWindowForCursorPosition(TInt aCursorPosition, TLogWindow& aWindow) const

 	{

 	aWindow.iLower = Max(0, aCursorPosition - KWindowSlideSize - 1);

 	aWindow.iUpper = Min(iViewRecordCount - 1, aWindow.iLower + iWindowSize - 1);

 	}

 void CLogViewWindow::Reset()

 	{

 	Cancel();

 	//

 	iViewRecordCount = 0;

 	iWindow.Reset();

 	iEvents.ResetAndDestroy();

 	iState = EStateIdle;

 	}

 void CLogViewWindow::SilentCancel()

 	{

 	iWindowFetcher->SilentCancel();

 	}

 void CLogViewWindow::RefetchL(const TLogWindow& aWindow, TInt aCursor)

 	{

 	SilentCancel();

 	//

 	TLogWindowAndCursor newWindow(aWindow, aCursor);

 	iWindowFetcher->PrepareToFetchWindowL(newWindow);

 	CompleteRequest(KErrNone);

 	ChangeState(EStateFetchingWindow);

 	}

 void CLogViewWindow::ChangeState(TWindowState aNewState)

 	{

 	iState = aNewState;

 	}

 void CLogViewWindow::RemoveEvent(TInt aIndex)

 	{

 	CLogEvent* event = iEvents[aIndex];

 	delete event;

 	iEvents.Remove(aIndex);

 	}

 TInt CLogViewWindow::CalculateCursorPosition(TLogNavigation aNavigate) const

 	{

 	TInt position = 0;

 	switch(aNavigate)

 		{

 	case ELogNavigateForwards:

 		position = iWindow.iCursorPosition + 1;

 		break;

 	case ELogNavigateBackwards:

 		position = iWindow.iCursorPosition - 1;

 		break;

 	case ELogNavigateFirst:

 		position = 0;

 		break;

 	case ELogNavigateLast:

 		position = iViewRecordCount - 1;

 		break;

 	default:

 		break;

 		}

 	return position;

 	}

 TInt CLogViewWindow::FindEvent(TLogId aId)

 	{

 	const TInt count = iEvents.Count();

 	for(TInt i=0; i<count; i++)

 		{

 		CLogEvent* event = iEvents[i];

 		if	(event->Id() == aId)

 			return i;

 		}

 	return KErrNotFound;

 	}

 TInt CLogViewWindow::FindAndRemoveEvent(TLogId aId)

 	{

 	TInt index = FindEvent(aId);

 	if	(index >= 0)

 		{

 		RemoveEvent(index);

 		index += iWindow.iLower;

 		}

 	return index;

 	}