/*

* 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:

*

*/

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <AvkonInternalCRKeys.h>

#include "hnmdmodel.h"

#include "hnmdsuite.h"

#include "hnrepositoryobserver.h"

#include "hnfilter.h"

#include "hnglobals.h"

#include "hneventhandler.h"

#include "hnmdlocalization.h"

#include "hnxmlmodelprovider.h"

#include "hnsuitemodelcontainer.h"

#include "hnitemsorder.h"

#include "hninterface.h"

#include "menudebug.h"

#include "hnconvutils.h"

#include "hnbitmapidcache.h"

// ======== MEMBER FUNCTIONS ========

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

//

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

//

void CHnMdModel::ConstructL( MHnMdModelEventObserver *aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer )

    {

    MMPERF(("CHnMetaDataModel::ConstructL - START"));

    MMPERF(("CHnMetaDataModel::ConstructL - query handler ready"));

    iLocalization = CHnMdLocalization::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - localization ready"));

    iXmlModelProvider = CHnXmlModelProvider::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - bitmap and mask ids cache ready"));

    iBitmapIdCache = CHnBitmapIdCache::NewL();

    MMPERF(("CHnMetaDataModel::ConstructL - model privider ready"));

    iCmnPtrs.iLocalization = iLocalization;

    iCmnPtrs.iIdGenerator = &iIdGenerator;

    iCmnPtrs.iModel = this;

    iCmnPtrs.iXmlModelProvider = iXmlModelProvider;

    iCmnPtrs.iContainer = aSuiteModelContainer;

    iCmnPtrs.iModelEventObserver = aModelObserver;

    iCmnPtrs.iBitmapIdCache = iBitmapIdCache;

    THnMdCommonPointers::SetStatic(&iCmnPtrs);

    iMode = EMdModeNormal;

    iRepositoryWidgetTypeObserver = CHnRepositoryWidgetTypeObserver::NewL( &iCmnPtrs, KMatrixRepositoryUid );

    iRepositoryShowFolderObserver = CHnRepositoryShowFolderObserver::NewL( &iCmnPtrs, KCRUidMenu, KMenuShowFolder );

    MMPERF(("CHnMetaDataModel::ConstructL - rep. observer ready"));

    }

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

//

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

//

EXPORT_C CHnMdModel* CHnMdModel::NewL(

        MHnMdModelEventObserver* aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer  )

    {

    CHnMdModel* self = CHnMdModel::NewLC( aModelObserver,

            aSuiteModelContainer );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CHnMdModel* CHnMdModel::NewLC(

        MHnMdModelEventObserver* aModelObserver,

        CHnSuiteModelContainer * aSuiteModelContainer )

    {

    CHnMdModel* self = new( ELeave ) CHnMdModel();

    CleanupStack::PushL( self );

    self->ConstructL( aModelObserver, aSuiteModelContainer );

    return self;

    }

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

//

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

//

CHnMdModel::CHnMdModel()

    {

    }

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

//

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

//

CHnMdModel::~CHnMdModel()

    {

    delete iRepositoryWidgetTypeObserver;

    delete iRepositoryShowFolderObserver;

    iLoadedSuites.ResetAndDestroy();

    delete iXmlModelProvider;

    delete iLocalization;

    delete iBitmapIdCache;

    }

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

//

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

//

EXPORT_C TInt CHnMdModel::HandleBackEventL(

        CHnSuiteModelContainer* aMulContainer,

        const TDesC& aSuiteName,

        TInt aIterations )

    {

    TInt ret( KErrNotFound );

#ifdef _DEBUG

    // check if genres match

    CHnMdSuite* lastMdModel = GetLastSuite();

    ASSERT( !lastMdModel->SuiteName().Compare( aSuiteName ) );

#endif

    TInt countDown( aIterations );

    CHnSuiteModel* current = NULL;

    while( ( current = aMulContainer->GetParentSuiteModel() ) != NULL &&

            countDown > 0 )

        {

        current = aMulContainer->GetLastSuiteModel();

        // pop the suite model

        aMulContainer->PopSuiteModelL( current->SuiteName() );

        // remove the suite that we are leaving

        DeleteLastSuite();

        countDown--;

        }

    current = aMulContainer->GetLastSuiteModel();

    current->GetItemsOrder()->MarkSuiteUninitialized();

    CHnFilter* filter = CHnFilter::NewLC();

    filter->SetSuiteNameL( current->SuiteName() );

    filter->SetSuiteId( current->CustomId() );

    GetLastSuite()->MarkEvaluationL( *filter, *current);

    CleanupStack::PopAndDestroy( filter );

    //Evaluate suite at the top (if needed)

    EvaluateTopSuiteL();

    return ret;

    }

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

//

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

//

EXPORT_C void CHnMdModel::DeleteLastSuite()

    {

    CHnMdSuite* tmpPtr = GetLastSuite();

    iLoadedSuites.Remove( iLoadedSuites.Count() - 1 );

    delete tmpPtr;

    }

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

//

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

//

EXPORT_C void CHnMdModel::EvaluateL()

    {

    CHnFilter* empty = CHnFilter::NewLC();

    EvaluateL( *empty );

    CleanupStack::PopAndDestroy( empty );

    }

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

//

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

//

EXPORT_C void CHnMdModel::SetModeL( TMdMode aMode )

    {

    iMode = aMode;

    for ( TInt i( 0 ); i < iLoadedSuites.Count(); i++ )

        {

        CHnMdSuite* suite = iLoadedSuites[i];

        ASSERT( suite != NULL );

        suite->SetModeL( aMode );

        }

    }

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

//

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

//

EXPORT_C CHnMdSuite* CHnMdModel::GetLastSuite()

    {

    return (iLoadedSuites.Count()>0)

            ? iLoadedSuites[ iLoadedSuites.Count()-1 ]

            : NULL;

    }

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

//

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

//

EXPORT_C void CHnMdModel::IgnoreEvaluations( TBool aIgnore )

    {

    iIgnoreEvaluations = aIgnore;

    }

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

//

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

//

EXPORT_C void CHnMdModel::QueueForeground(

        TForegroundGainTriggeringEvent aWhen )

    {

    switch ( aWhen )

        {

        case EWhenAnySuiteIsEvaluated:

            iForegroundQueued = ETrue;

            iForegroundTriggeringSuite = NULL;

            break;

        case EWhenCurrentTopSuiteIsEvaluated:

            iForegroundQueued = ETrue;

            iForegroundTriggeringSuite = iCmnPtrs.iContainer->GetLastSuiteModel();

            break;

        case ENever:

            iForegroundQueued = EFalse;

            iForegroundTriggeringSuite = NULL;

            break;

        default:

            ASSERT( 0 );

        }

    }

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

//

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

//

EXPORT_C TBool CHnMdModel::IsForegroundQueued() const

    {

    return iForegroundQueued;

    }

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

//

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

//

void CHnMdModel::SuiteModelReadyToShowL( CHnSuiteModel* aJustEvaluatedSuite )

    {

    if ( !aJustEvaluatedSuite )

        {

        User::Leave( KErrArgument );

        }

    if ( IsForegroundQueued() && ( !iForegroundTriggeringSuite ||

            iForegroundTriggeringSuite == aJustEvaluatedSuite ) )

        {

        CLiwGenericParamList* pl = CLiwGenericParamList::NewL();

        CleanupStack::PushL( pl );

        iCmnPtrs.iModelEventObserver->HandleModelEventL( KAppGainForeground, *pl );

        CleanupStack::PopAndDestroy( pl );

        QueueForeground( ENever );

        }

    }

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

//

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

//

CHnMdSuite* CHnMdModel::GetSuite( TInt aPosition )

    {

    return ( (aPosition >= 0) && (aPosition < iLoadedSuites.Count()) )

            ? iLoadedSuites[ aPosition ]

            : NULL;

    }

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

//

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

//

EXPORT_C CLiwGenericParamList& CHnMdModel::GetSuiteParameters( TInt aPosition )

    {

    return GetSuite( aPosition )->GetSuiteParameters();

    }

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

//

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

//

EXPORT_C void CHnMdModel::EvaluateL( CHnFilter& aFilter )

    {

    for ( TInt i = iLoadedSuites.Count() - 1; i >= 0; i-- )

        {

        iLoadedSuites[i]->MarkEvaluationL( aFilter, *iCmnPtrs.iContainer->GetSuiteModel(i) );

        if( i == iLoadedSuites.Count() - 1 && !iIgnoreEvaluations )

            {

            iLoadedSuites[i]->EvaluateL( *iCmnPtrs.iContainer->GetSuiteModel(i) );

            }

        }

    }

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

//

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

//

EXPORT_C TInt CHnMdModel::LoadSuiteL( const TDesC& aGenre,

        CLiwGenericParamList* aSuiteParams )

    {

    TInt err( KErrNone );

    RXmlEngDocument xmlDoc;

    // Xml model provider takes ownership of xmlDoc.

    TRAP( err, iXmlModelProvider->GetModelL( aGenre, xmlDoc ) );

    TXmlEngElement element;

    if ( !err )

        {

        element = xmlDoc.DocumentElement().AsElement();

        if ( element.Name() != KContentElementName8 )

            {

            err = KErrCorrupt;

            }

        }

    if ( !err )

        {

        CHnMdSuite* newSuite = CHnMdSuite::NewLC( element, &iCmnPtrs );

        if (aSuiteParams)

            {

            newSuite->SetSuiteParametersL( *aSuiteParams );

            }

        TInt pos( 0 );

        newSuite->GetSuiteParameters().FindFirst( pos, KSuiteName8);

        if ( pos == KErrNotFound )

            {

            newSuite->GetSuiteParameters().AppendL(

                TLiwGenericParam(KSuiteName8, TLiwVariant( aGenre ) ) );

            }

        iCmnPtrs.iContainer->PushNewSuiteModelL( newSuite->SuiteName() );

        iCmnPtrs.iContainer->GetLastSuiteModel()->GetItemsOrder()->

            SetSuiteId( iCmnPtrs.iIdGenerator->GetNextId() );

        CleanupStack::Pop( newSuite );

        iLoadedSuites.AppendL( newSuite );

        }

    else

        {

        MMPERF(("CHnMdModel::LoadSuiteL - Error TRAPPED!"));

        }

    return err;

    }

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

//

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

//

EXPORT_C TBool CHnMdModel::SuiteModelExistsL( const TDesC8& aSuiteModel )

    {

    TBool res( EFalse );

    if( !aSuiteModel.Compare( KFolderSuite8 ) ||

        !aSuiteModel.Compare( KRoot8 ) )

        {

        res = ETrue;

        }

    return res;

    }

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

//

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

//

void CHnMdModel::EvaluateTopSuiteL()

    {

    if ( !iIgnoreEvaluations )

        {

        TInt topItem = iLoadedSuites.Count() - 1;

        iLoadedSuites[topItem]->EvaluateL( *iCmnPtrs.iContainer->GetSuiteModel(topItem) );

        }

    }

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

//

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

//

TInt CHnMdModel::LoadedSuitesCount()

    {

    return iLoadedSuites.Count();

    }