/*

* 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 model interface

*

*/

//Includes

// class headers

#include "mulmodelimpl.h"

#include <mul/mulvarianttype.h>

// Local Headers

#include "mulcachemanager.h"

#include "muldatawindow.h"

#include "mulpagedatawindow.h"

#include "mulpushmode.h"

#include "mulpullmode.h"

#include "mulassert.h"

#include "mulmodeldef.h"

#include "mullog.h"

namespace Alf

    { 

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

// MulModelImpl()

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

//

OSN_EXPORT MulModelImpl::MulModelImpl()

	{	

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::MulModelImpl()");  	

	//mDataWindow.reset( new ( EMM ) MulDataWindow( *this ));

	mDataWindow.reset( new ( EMM ) MulPageDataWindow( *this ));  	

	mModelHelper.reset(new (EMM) MulPushMode(*mDataWindow ));

	}

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

// ~MulModelImpl()

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

//

OSN_EXPORT MulModelImpl::~MulModelImpl()

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::~MulModelImpl()");   

	mObserverArray.clear();

	}

// ------------------------ From IMulModel -----------------------------------

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

// Insert

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

//

void MulModelImpl::Insert(int aIndex, int aCount,const MulDataPath& aPath)

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::Insert()"); 

	MUL_LOG_INFO2("MUL::MulModelImpl::Insert() index:%d,count:%d",aIndex,aCount);

	mModelHelper->Insert(aIndex, aCount,aPath);

	if( aCount > 0  &&  mDataWindow->Highlight() == KNotInitialized )

		{

		mDataWindow->UpdateHighlight(0);

		NotifyDataChange( IMulModelObserver::EHighlightChanged , 0 );

		}

	NotifyDataChange( IMulModelObserver::EItemsInserted, aIndex, aCount );

	}

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

// Remove

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

//

void MulModelImpl::Remove(int aIndex, int aCount, const MulDataPath& aPath)

	{

	// If the highlight has changed because of the remove then inform the widget

	if( mModelHelper->Remove(aIndex, aCount, aPath) )

		{

		NotifyDataChange( IMulModelObserver::EHighlightChanged , mDataWindow->Highlight() );

		}

	NotifyDataChange( IMulModelObserver::EItemsRemoved, aIndex, aCount );

	}

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

// Update

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

//

void MulModelImpl::Update( int aIndex, int aCount, const MulDataPath& aPath )

	{

	mModelHelper->Update( aIndex, aCount, aPath );

	}

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

// Refresh

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

//

void MulModelImpl::Refresh( int aCount, const MulDataPath& aPath )

	{	

	mModelHelper->Refresh( aCount, aPath );

	NotifyDataChange( IMulModelObserver::EModelRefreshed , aCount );

	}

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

// SetData

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

//

void MulModelImpl::SetData( int aIndex, auto_ptr<MulVisualItem> aVisualItem, const MulDataPath& aPath )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::SetData()");  		

	MUL_LOG_INFO1("MUL::MulModelImpl::SetData() index:%d",aIndex );

	mModelHelper->SetData( aIndex, aVisualItem, aPath );

	NotifyDataChange( IMulModelObserver::EItemUpdated , aIndex );

	}

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

// Data

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

//

const MulVisualItem* MulModelImpl::Data( int aIndex, const MulDataPath& aPath) const

	{

	return mModelHelper->Data( aIndex, aPath );

	}

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

// Count

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

//

int MulModelImpl::Count( const MulDataPath& aPath) const

	{

	return mModelHelper->Count( aPath );

	}

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

// SetDataProvider

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

//

void MulModelImpl::SetDataProvider( const IMulModelProvider& aDataProvider )

	{	

	mModelHelper.reset(new (EMM) MulPullMode( *mDataWindow, aDataProvider ) );	

	}

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

// SetTemplate

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

//

void MulModelImpl::SetTemplate( mulwidget::TLogicalTemplate aTemplateId )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::SetTemplate");

	mModelHelper->SetTemplate( aTemplateId );

	// default template updated

	NotifyTemplateChange( -1, aTemplateId );

	}

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

// SetTemplate

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

//

void MulModelImpl::SetTemplate(int aItemIndex, mulwidget::TLogicalTemplate aTemplateId, const MulDataPath& aPath )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulModelImpl::SetTemplate");

	mModelHelper->SetTemplate(aItemIndex, aTemplateId, aPath );

	NotifyTemplateChange( aItemIndex, aTemplateId );

	}

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

// SetDataWindow

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

//

void MulModelImpl::SetDataWindow( int aBufferSize )

	{

	mDataWindow->SetBufferSize( aBufferSize );

	}

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

// DataWindow

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

//

int MulModelImpl::DataWindow() const         

	{

	return mDataWindow->BufferSize();

	}

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

// SetHighlight

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

//

void MulModelImpl::SetHighlight( int aItemIndex, const MulDataPath& /*aPath*/ )

	{

	mDataWindow->SetHighlight( aItemIndex );

	NotifyDataChange( IMulModelObserver::EHighlightChanged , aItemIndex );

	}

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

// Highlight

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

//

int MulModelImpl::Highlight( MulDataPath& /*aPath*/ )

	{

	return mDataWindow->Highlight();	

	}

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

// Highlight

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

//

int MulModelImpl::Highlight()

	{

	return 	mDataWindow->Highlight();

	}

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

// SetMarkedIndices

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

//

void MulModelImpl::SetMarkedIndices( MulWidgetDef::TMulWidgetMarkingType aType,

									 const std::vector<int>& aItemsIndex,

									 const MulDataPath& aPath )

	{

	//fire update event in alf model

	mModelHelper->CacheManager().SetMarkedIndices( aType, aItemsIndex, aPath );

	for( int i = 0 ; i < aItemsIndex.size() ; i++ )

	    {

	    if(mDataWindow->IsItemInDataWindow(aItemsIndex[i]))

	        {

	        CreateMarkingEvent(aItemsIndex[i]);

	        }

	    }

	}

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

// SetMarkedIndices

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

//

void MulModelImpl::SetMarkedIndices(MulWidgetDef::TMulWidgetMarkingType aType)

	{

	//fire update event in alf model

	mModelHelper->CacheManager().SetMarkedIndices( aType );

	for( int i = mDataWindow->TopOffset() ; i <= mDataWindow->BottomOffset() ; i++ )

        {

        CreateMarkingEvent(i);

        }

	for( int i = mDataWindow->RearTopOffset( ); i <= mDataWindow->RearBottomOffset() && i > 0 ; i++ )

        {

        CreateMarkingEvent(i);

        }

	}

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

// CreateMarkingEvent

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

//

void MulModelImpl::CreateMarkingEvent(int aAbsoluteIndex)

	{

	NotifyDataChange( IMulModelObserver::EMarkingChanged , aAbsoluteIndex );

	}

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

// NotifyStateChange

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

//

void MulModelImpl::NotifyStateChange( IMulModelObserver::TMulChangedState aState, 

									  std::auto_ptr<IMulVariantType> aData)

	{

	for( int i = 0; i < mObserverArray.size(); ++i )

		{

		mObserverArray[i]->ModelStateChanged( aState, *aData );

		}

	}

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

// NotifyDataChange

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

//

void MulModelImpl::NotifyDataChange( IMulModelObserver::TMulChangedState aState, 

                                      int aStartIndex, int aCount )

    {

    std::auto_ptr<IAlfMap> map( new ( EMM )AlfMap() );

    map->addItem( new (EMM) AlfVariantType(aStartIndex),UString(KStartIndex));

    map->addItem( new (EMM) AlfVariantType(aCount),UString(KCount));

    std::auto_ptr<IMulVariantType> data(new (EMM)MulVariantType(*map));

    NotifyStateChange( aState , data );

    }

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

// NotifyDataChange

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

//

void MulModelImpl::NotifyDataChange( IMulModelObserver::TMulChangedState aState, int aIndex )

    {    

    std::auto_ptr<IMulVariantType> data(new (EMM)MulVariantType(aIndex));

    NotifyStateChange( aState , data );

    }

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

// NotifyTemplateChange

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

//

void MulModelImpl::NotifyTemplateChange( int aIndex, mulwidget::TLogicalTemplate aTamplateId )

    {

    std::auto_ptr<IAlfMap> map( new ( EMM )AlfMap() );

    map->addItem(new (EMM) AlfVariantType(aTamplateId),osncore::UString(KDefaultTemplate));

    map->addItem(new (EMM) AlfVariantType(aIndex),osncore::UString(KIndex));

    std::auto_ptr<IMulVariantType> data(new (EMM)MulVariantType(*map));

    NotifyStateChange( IMulModelObserver::ETemplateChanged , data );

    }

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

// MarkedIndices

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

//

const std::vector<int>& MulModelImpl::MarkedIndices(const MulDataPath& aPath )

	{	

	return mModelHelper->CacheManager().MarkedIndices( aPath );	

	}

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

// IsLoopingOn

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

//

bool MulModelImpl::IsLoopingOn()

	{

	return ( mDataWindow->RearBottomOffset() != -1 && mDataWindow->OldRearBottomOffset() != -1 ); 

	}

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

// AddModelObserver

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

//

void MulModelImpl::AddModelObserver( IMulModelObserver* aObserver )

    {

    __MUL_ASSERT(aObserver, KLInvalidArgument );

    if( std::find(mObserverArray.begin(), mObserverArray.end(), aObserver) == mObserverArray.end() )

        {

        mObserverArray.push_back( aObserver );  

        }

    }

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

// RemoveModelObserver

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

//

void MulModelImpl::RemoveModelObserver( IMulModelObserver* aObserver )

    {

    __MUL_ASSERT(aObserver, KLInvalidArgument );

    if( std::find(mObserverArray.begin(), mObserverArray.end(), aObserver ) != mObserverArray.end() )

       {

       mObserverArray.erase( std::find( mObserverArray.begin(), mObserverArray.end(), aObserver ));  

       }

    }

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

// RemoveModelObserver

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

//

mulwidget::TLogicalTemplate MulModelImpl::Template()

    {

    return mModelHelper->Template();

    }

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

// Accessor

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

//

IMulModelAccessor* MulModelImpl::Accessor()

	{

	return this;

	}

// ------------------------ From IMulModelAccessor ---------------------------

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

// SetHighlight

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

//

void MulModelImpl::SetHighlight( int aItemIndex )

	{

	mDataWindow->SetHighlight( aItemIndex );

	}

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

// ScrollWindow

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

//

void MulModelImpl::ScrollWindow( int aItemIndex )

	{

	mDataWindow->ScrollWindow( aItemIndex );

	}

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

// CurrentItemCount

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

//

int MulModelImpl::CurrentItemCount()

	{

	return mModelHelper->CurrentItemCount();

	}

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

// SetDataWindow

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

//

void MulModelImpl::SetVisibleWindow(  int aWindowSize, int aPageTopIndex )

	{

	mDataWindow->SetWindowSize( aWindowSize, aPageTopIndex );

	}

// ------------------------ Member Function ----------------------------------

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

// DataWindowUpdated

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

//

void MulModelImpl::DataWindowUpdated()

	{

	mModelHelper->DataWindowUpdated();

	std::auto_ptr<IMulVariantType> dummyData;

	NotifyStateChange( IMulModelObserver::EDataWindowUpdated, dummyData );			

	}

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

// RelativeIndex

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

//

int MulModelImpl::RelativeIndex( int aAbsoluteIndex ) const

	{

	return mDataWindow->RelativeIndex(aAbsoluteIndex);

	}

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

// TopWindowOffset

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

//

int MulModelImpl::TopWindowOffset() const

	{

	return mDataWindow->TopWindowOffset();

	}

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

// BottomWindowOffset

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

//

int MulModelImpl::BottomWindowOffset() const

	{

	return mDataWindow->BottomWindowOffset();

	}

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

// TopOffset

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

//

int MulModelImpl::TopOffset() const

	{

	return mDataWindow->TopOffset();

	}

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

// BottomOffset

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

//

int MulModelImpl::BottomOffset() const

	{

	return mDataWindow->BottomOffset();

	}

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

// RearTopOffset

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

//

int MulModelImpl::RearTopOffset() const

	{

	return mDataWindow->RearTopOffset();

	}

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

// RearBottomOffset

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

//

int MulModelImpl::RearBottomOffset() const

	{

	return mDataWindow->RearBottomOffset();

	}

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

// IsItemMarked

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

//  

bool MulModelImpl::IsItemMarked( int aIndex )

	{

	return mModelHelper->CacheManager().IsItemMarked(aIndex);

	}

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

// Item

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

//

const MulVisualItem& MulModelImpl::Item( int aAbsoluteIndex )

	{

	return mModelHelper->Item( aAbsoluteIndex );

	}

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

// AbsoluteIndex

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

//

int MulModelImpl::AbsoluteIndex( int aRelativeIndex )

	{

	return mDataWindow->AbsoluteIndex(aRelativeIndex);

	}