/*

* Copyright (c) 2007-2008 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:  Implementation of Data window

*

*/

//Includes

#include "mulpagedatawindow.h"

#include <stdexcept>

//Internal includes

#include "mulassert.h"

#include "mulmodelimpl.h"

#include "mullog.h"

using namespace std;

namespace Alf

    {

// ---------------------------------------------------------------------------

// MulPageDataWindow

// ---------------------------------------------------------------------------

//

MulPageDataWindow::MulPageDataWindow( MulModelImpl& aMulModel )

			  :mMulModel( aMulModel ),

			   mHighlight(KNotInitialized),

			   mPageTopIndex(KNotInitialized),

			   mOldPageTopIndex(KNotInitialized),

			   mBufferSize(KNotInitialized),

			   mWindowSize(KNotInitialized),

			   mWindowTop(KNotInitialized),

			   mWindowBottom(KNotInitialized),

			   mBufferTop(0),

			   mBufferBottom(0),

			   mOldBufferTop(KNotInitialized),

			   mOldBufferBottom(KNotInitialized),

			   mRearBufferTop(0),

			   mRearBufferBottom(0),

			   mOldRearBufferTop(KNotInitialized),

			   mOldRearBufferBottom(KNotInitialized)

	{	

	}

// ---------------------------------------------------------------------------

// SetWindowSize

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::SetWindowSize( int aWindowSize, int aPageTopIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulDataWindow::SetWindowSize()"); 

	__MUL_ASSERT( aWindowSize > 0, KLInvalidArgument );

	if( mWindowSize != aWindowSize ||  mWindowTop != aPageTopIndex)

		{

		if( KNotInitialized == mBufferSize )

			{

			mBufferSize = aWindowSize;			

			}

		mWindowSize = aWindowSize;

		mOldPageTopIndex = mPageTopIndex;

		mPageTopIndex = aPageTopIndex; 

		/*adjusting window offset

		//if window size changes then the top and bottom offset should be 

		//adjusted such that highlight remains at the centre

		//window top and bottom are inclusive*/

		//assing page top index to window top by default aPageTopIndex is KNotInitialized

		mWindowTop = aPageTopIndex ;

		mWindowTop = ( mWindowTop == KNotInitialized ) ? 0 : mWindowTop;			

		mWindowBottom = mWindowTop + mWindowSize - 1;

		//make sure that window bottom is not more than model count

		mWindowBottom = mWindowBottom >= mMulModel.CurrentItemCount() ? ( mMulModel.CurrentItemCount() -1) : mWindowBottom;	

		MUL_LOG_INFO2("MUL::MulDataWindow::SetWindowSize() mWindowTop:%d,mWindowBottom:%d",mWindowTop,mWindowBottom); 

		AdjustBuffer();

		mMulModel.DataWindowUpdated();

		}

	//else nothing needed

	}

// ---------------------------------------------------------------------------

// SetBufferSize

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::SetBufferSize( int aBufferSize )

	{	

	MUL_LOG_ENTRY_EXIT("MUL::MulDataWindow::SetBufferSize()"); 

	__MUL_ASSERT( aBufferSize > 0, KLInvalidArgument );

	if( mBufferSize != aBufferSize )

		{			

		mBufferSize = aBufferSize;

		if(mMulModel.CurrentItemCount() > 0)

			{

			AdjustBuffer();

			mMulModel.DataWindowUpdated();

			}

		}

	//else nothing needed

	}

// ---------------------------------------------------------------------------

// ~MulDataWindow

// ---------------------------------------------------------------------------

//

MulPageDataWindow::~MulPageDataWindow()

	{

	// do nothing

	}

// ---------------------------------------------------------------------------

// SetHighlight

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::SetHighlight( int aHighlightIndex )

	{	

	MUL_LOG_INFO2("MUL::MulDataWindow::SetHighlight() mHighlight:%d,modelCount:%d",aHighlightIndex,mMulModel.CurrentItemCount()); 

	__MUL_ASSERT( aHighlightIndex >= 0 && aHighlightIndex <= mMulModel.CurrentItemCount()-1, KLInvalidArgument );

	mHighlight = aHighlightIndex; 

	}

// ---------------------------------------------------------------------------

// UpdateHighlight

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::UpdateHighlight( int aHighlightIndex )

	{

	// No need to assert. We should send highlight -1 when all the items are removed.

	// Widget should handle. to show emty text visualization

	mHighlight = aHighlightIndex; 

	}

// ---------------------------------------------------------------------------

// AdjustOffset

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::AdjustOffset()

    {

    if( BottomWindowOffset() >= mMulModel.CurrentItemCount() )

        {

        mWindowBottom = mMulModel.CurrentItemCount() -1;

        mWindowTop = mWindowBottom - WindowSize() + 1;

        mWindowTop = mWindowTop < 0 ? 0 : mWindowTop;

        MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustOffset() : windowTop:%d::windowBottom%d",mWindowTop,mWindowBottom);

        }

    else if( (BottomWindowOffset() - TopWindowOffset() +1 ) < WindowSize() )

        {

        mWindowTop = 0;

        mWindowBottom = mWindowTop + WindowSize() -1;

        int modelCount = mMulModel.CurrentItemCount();

        mWindowBottom = mWindowBottom >=  modelCount ? (modelCount - 1) : mWindowBottom;

        MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustOffset() :: windowTop:%d::windowBottom%d",mWindowTop,mWindowBottom);       

        }

    // save old values to check if teh buffer offsets are modified. If the buffer offsets are 

    // modified then should inform the widget to update the visualization

    SaveOldValues();

    AdjustBuffer();

    }

// ---------------------------------------------------------------------------

// ScrollWindow

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::ScrollWindow( int aPageTopIndex )

	{

	MUL_LOG_INFO2("MUL::MulDataWindow::ScrollWindow() aPageTopIndex:%d,modelCount:%d",aPageTopIndex,mMulModel.CurrentItemCount()); 

	__MUL_ASSERT( aPageTopIndex >= 0 && aPageTopIndex <= mMulModel.CurrentItemCount()-1, KLInvalidArgument );

	if( mPageTopIndex != aPageTopIndex )

		{

		mOldPageTopIndex = mPageTopIndex;

		mPageTopIndex = aPageTopIndex; 

		UpdateDataWindow();

		}

	//else same highlight

	}

// ---------------------------------------------------------------------------

// UpdateDataWindow

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::UpdateDataWindow()

	{

	MUL_LOG_INFO1("MUL::MulPageDataWindow::UpdateDataWindow() diff:%d ", mPageTopIndex - mOldPageTopIndex ); 

	//If diffrence is negative than highlight is moved up else down

	//(( mPageTopIndex - mOldPageTopIndex ) < 0 ) ? ShiftWindowUp() : ShiftWindowDown() ;

	MUL_LOG_ENTRY_EXIT("MUL::MulPageDataWindow::ShiftWindowDown()");  

    MUL_LOG_INFO2("MUL::MulPageDataWindow::ShiftWindowDown() mPageTopIndex:%d,mWindowBottom:%d",mPageTopIndex,mWindowBottom); 

    mWindowTop = mPageTopIndex;

    mWindowBottom = mWindowTop + mWindowSize -1;

    //bottom can't exceeding model count

    mWindowBottom = mWindowBottom >= mMulModel.CurrentItemCount() ? 

                    mWindowBottom = mMulModel.CurrentItemCount() - 1 : mWindowBottom;

    MUL_LOG_INFO2("MUL::MulDataWindow::ShiftWindowDown() mWindowTop:%d,mWindowBottom:%d",mWindowTop,mWindowBottom);                     

    SaveOldValues();

    AdjustBuffer();

    mMulModel.DataWindowUpdated();

	}

// ---------------------------------------------------------------------------

// AdjustBuffer

// ---------------------------------------------------------------------------

//

void MulPageDataWindow::AdjustBuffer()

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulPageDataWindow::AdjustBuffer()");  

	int modelCount = mMulModel.CurrentItemCount() -1;

	//remove data is new window is smaller/add is new window is bigger

	//create rear buffer only if model has more data

	if( mWindowTop == 0 && ActualBufferSize() <= modelCount )

		{		

		MUL_LOG_INFO("MUL::MulPageDataWindow::AdjustBuffer() mWindowTop == 0 ");  		

		mBufferTop = mWindowTop;

		mBufferBottom = mBufferTop + mWindowSize + mBufferSize - 1;

		//Create rear top and rear bottom only in looping case

		//window top is zero so data at other end should be buffered

		mRearBufferBottom = modelCount;

		mRearBufferTop = mRearBufferBottom - mBufferSize +1;		

		}

	else if( mWindowBottom == modelCount && ActualBufferSize() <= modelCount )

		{

		MUL_LOG_INFO("MUL::MulPageDataWindow::AdjustBuffer() mWindowBottom == modelCount ");  

		mBufferBottom = mWindowBottom ;

		mBufferTop = mBufferBottom - (mWindowSize + mBufferSize) + 1;

		//Create rear top and rear bottom only in looping case

		//window bottom is equal to model count so data at other end should be buffered

		mRearBufferTop = 0;

		mRearBufferBottom = mRearBufferTop + mBufferSize -1 ;

		}

	else

		{

		MUL_LOG_INFO("MUL::MulPageDataWindow::AdjustBuffer() else ");  

		mBufferTop = mWindowTop - mBufferSize;

		mBufferBottom = mWindowBottom + mBufferSize;

		//check if top or bottom is out of bound and update offset accordingly

		if( mBufferTop < 0 )

			{

			MUL_LOG_INFO("MUL::MulPageDataWindow::AdjustBuffer() mBufferTop < 0 "); 

			mBufferTop = 0;

			mBufferBottom = mBufferTop + ActualBufferSize()  - 1;

			//buffer bottom cant be larger then model count

			mBufferBottom = mBufferBottom > modelCount ? modelCount : mBufferBottom;

			}

		else if( mBufferBottom > modelCount )

			{

			MUL_LOG_INFO("MUL::MulPageDataWindow::AdjustBuffer() mBufferBottom > modelCount"); 

			mBufferBottom = modelCount ;

			mBufferTop = mBufferBottom - ActualBufferSize() + 1;

			//buffer top cant be less then 0

			mBufferTop = mBufferTop < 0 ? 0 : mBufferTop;

			}

		//in other case rear top and rear bottom is not use set to -1

		mRearBufferTop = KNotInitialized;

		mRearBufferBottom = KNotInitialized;

		}

	MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustBuffer() mOldBufferTop:%d,mOldBufferBottom:%d",mOldBufferTop,mOldBufferBottom); 

	MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustBuffer() mOldRearBufferBottom:%d,mOldRearBufferTop:%d",mOldRearBufferBottom,mOldRearBufferTop); 

	MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustBuffer() mBufferTop:%d,mBufferBottom:%d",mBufferTop,mBufferBottom); 

	MUL_LOG_INFO2("MUL::MulPageDataWindow::AdjustBuffer() mRearBufferBottom:%d,mRearBufferTop:%d",mRearBufferBottom,mRearBufferTop); 

	__MUL_ASSERT_DEBUG( mWindowTop >= 0 && mWindowBottom < mMulModel.CurrentItemCount(), _L("Invlid Window"));

	__MUL_ASSERT_DEBUG( mBufferTop >= 0 && mBufferBottom < mMulModel.CurrentItemCount(), _L("Invlid Buffer"));

	}

// ---------------------------------------------------------------------------

// IsItemInDataWindow

// ---------------------------------------------------------------------------

//

bool MulPageDataWindow::IsItemInDataWindow(int aItemIndex ) const

	{

	//__MUL_ASSERT_DEBUG( aItemIndex >= 0 && aItemIndex <= mMulModel.CurrentItemCount()-1, KLInvalidArgument );

	bool result( false );

	if(mWindowSize == KNotInitialized )

		{

		result = false;

		}

	//check that rear buffer is on or not in looping case

	else if( mRearBufferTop != KNotInitialized && mRearBufferBottom != KNotInitialized )

		{

		if( ( aItemIndex >= mBufferTop &&  aItemIndex <= mBufferBottom ) || 

			( aItemIndex >= mRearBufferTop &&  aItemIndex <= mRearBufferBottom )	)

			{

			result = true;

			}

		}

	else if( aItemIndex >= mBufferTop &&  aItemIndex <= mBufferBottom )

		{

		result = true;

		}

	return result;

	}

// ---------------------------------------------------------------------------

// IsItemInDataWindow

// ---------------------------------------------------------------------------

//

bool MulPageDataWindow::IsItemInVisibleWindow(int aItemIndex ) const

    {

    //__MUL_ASSERT_DEBUG( aItemIndex >= 0 && aItemIndex <= mMulModel.CurrentItemCount()-1, KLInvalidArgument );

    if(mWindowSize == KNotInitialized )

        {

        return false;

        }

    else if( aItemIndex >= mWindowTop &&  aItemIndex <= mWindowBottom )

        {

        return true;

        }

    return false;

    }

// ---------------------------------------------------------------------------

// RelativeIndex

// ---------------------------------------------------------------------------

//

int MulPageDataWindow::RelativeIndex( int aAbsoluteIndex ) const

	{

	__MUL_ASSERT_DEBUG( aAbsoluteIndex >= 0 && aAbsoluteIndex <= mMulModel.CurrentItemCount()-1, KLInvalidArgument );

	if( !IsItemInDataWindow(aAbsoluteIndex) )

	    {

	    return -1;

	    }

	if( mRearBufferTop != KNotInitialized && mRearBufferBottom != KNotInitialized )

		{

		if( mRearBufferBottom == mMulModel.CurrentItemCount() - 1 )

			{

			if( aAbsoluteIndex >= mRearBufferTop && aAbsoluteIndex <= mRearBufferBottom )	

				{

				int bufferSize = BottomOffset() - TopOffset() + 1;

				int rearDiff = aAbsoluteIndex - mRearBufferTop;

				int relativeIndex = bufferSize + rearDiff;

				return relativeIndex;

				}

			else

				{

				int relativeIndex = aAbsoluteIndex < TopOffset() ? 

									aAbsoluteIndex : aAbsoluteIndex - TopOffset() ;	

				return relativeIndex;	

				}		

			}

		else

			{

			if( aAbsoluteIndex >= mRearBufferTop && aAbsoluteIndex <= mRearBufferBottom )

				{

				int relativeIndex = aAbsoluteIndex < TopOffset() ? 

									aAbsoluteIndex : aAbsoluteIndex - TopOffset() ;	

				return relativeIndex;	

				}

			else

				{	

				int bufferSize = mRearBufferBottom - mRearBufferTop + 1;

				int diff = aAbsoluteIndex - TopOffset();

				int relativeIndex = bufferSize + diff;

				return relativeIndex;		

				}

			}

		}

	else

		{		

		int relativeIndex = aAbsoluteIndex < TopOffset() ? 

							aAbsoluteIndex : aAbsoluteIndex - TopOffset() ;	

		return relativeIndex;

		}

	}

// ---------------------------------------------------------------------------

// AbsoluteIndex

// ---------------------------------------------------------------------------

//

int MulPageDataWindow::AbsoluteIndex( int aRelativeIndex ) const

	{

	__MUL_ASSERT_DEBUG( aRelativeIndex >= 0 && aRelativeIndex <= ActualBufferSize(), _L("Invalid Relative Index"));

	if( mRearBufferTop != KNotInitialized && mRearBufferBottom != KNotInitialized )

		{

		if( mRearBufferBottom == mMulModel.CurrentItemCount() - 1 )

			{

			if( aRelativeIndex > BottomOffset() )

				{

				//relative index is in loop buffer

				int diff = aRelativeIndex - BottomOffset() - 1;

				int absoluteIndex = RearTopOffset() + diff;

				return absoluteIndex;

				}

			else

				{

				int absoluteIndex = TopOffset() + aRelativeIndex;

				return absoluteIndex;

				}

			}

		else

			{

			if( aRelativeIndex <= RearBottomOffset() )

				{

				//relative index is in loop buffer

				int absoluteIndex = RearTopOffset() + aRelativeIndex;

				return absoluteIndex;

				}

			else

				{

				int diff = aRelativeIndex - RearBottomOffset() - 1;

				int absoluteIndex = TopOffset() + diff;

				return absoluteIndex;

				}

			}

		}

	else

		{		

		int absoluteIndex = TopOffset() + aRelativeIndex;

		return absoluteIndex;

		}

	}

// ---------------------------------------------------------------------------

// IsBufferOffsetChanged

// ---------------------------------------------------------------------------

//

bool MulPageDataWindow::IsBufferOffsetChanged()

	{

	if(mRearBufferBottom != mOldRearBufferBottom || 

	   mRearBufferTop != mOldRearBufferTop || 

	   mBufferTop != mOldBufferTop || 

	   mBufferBottom != mOldBufferBottom )

		{

		return true;

		}

	return false;

	}

    } // namespace Alf

//End of file