MCL/sf/app/homescreen: comparison menufw/hierarchynavigator/hnengine/src/hnengine.cpp

equal deleted inserted replaced

-:f72a12da539e
+:5315654608de
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
 #include <uri8.h>
 #include <mmf/common/mmfcontrollerpluginresolver.h>
 #include <sacls.h>
 #include <apgtask.h>
 #include <centralrepository.h>
 #include <AknUtils.h>
 #include "hnengine.h"
 #include "hnconvutils.h"
 //
 // ---------------------------------------------------------------------------
 //
 CHnSuiteModel* CHnEngine::GetLastSuiteModelL()
 {
 return iSuiteContainer->GetLastSuiteModel();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CHnSuiteModel* CHnEngine::GetParentSuiteModelL()
 {
 return iSuiteContainer->GetParentSuiteModel();
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TInt CHnEngine::TriggerHnEventL( const TInt aHnEventId,
 const TInt aRecipientId, CLiwGenericParamList* aEventParameters )
 {
 TInt ret = iSuiteContainer->OfferHnEventL( aHnEventId, aRecipientId,
 aEventParameters);
 return ret;
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::LoadSuiteFromUriL( const TDesC8& aSuiteName,
 const TDesC8& aUriQuery, const TDesC8& aUriFragment )
 {
 TInt error( KErrNone );
 if( !( aSuiteName.Compare( KRoot8 ) ) )
 {
 CLiwGenericParamList* uriParams =
 			UriQueryToLiwListLC( aUriQuery, aUriFragment, aSuiteName );
 CLiwGenericParamList* params = CLiwGenericParamList::NewLC();
 params->AppendL( iMetaDataModel->GetSuiteParameters( 0 ) );
 params->AppendL( *uriParams );
 ResetModelsL();
 {
 CLiwGenericParamList* params =
 			UriQueryToLiwListLC( aUriQuery, aUriFragment, aSuiteName );
 HBufC* suiteName = HnConvUtils::Str8ToStrLC( aSuiteName );
 params->AppendL( TLiwGenericParam( KNewSuiteParamNameEn,
 TLiwVariant( *suiteName ) ) );
 error = HandleNewSuiteLoadedEventL( *params );
 CleanupStack::PopAndDestroy( suiteName );
 CleanupStack::PopAndDestroy( params );
 }
 return error;
 }
 // ---------------------------------------------------------------------------
 //
 if ( !exitMode.Compare( KExitModeHide ) )
 {
 // set parameters
 iSuiteContainer->GetLastSuiteModel()->SetExitMode( EExitModeHide );
 }
 CleanupStack::PopAndDestroy( params );
 CleanupStack::PopAndDestroy( &exitMode );
 if ( !aNextExists )
 {
 //
 EXPORT_C void CHnEngine::LoadSuitesFromUriL( const TDesC8& aUri )
 	{
 	DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL IN"));
 	DEBUG8(("_MM_:\tURI: %S",&aUri));
 	TBool consumed(EFalse);
 if ( aUri.Find( KSetFocusWithPref ) != KErrNotFound )
 	    {
 	    LoadFromCrL( aUri );
 	    consumed = ETrue;
 	    }
 if ( !consumed )
 	{
 	consumed = HandleActionL( aUri );
 	}
 if ( !consumed )
 	{
 	LoadSuitesL( aUri );
 	}
 DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL OUT"));
 }
 // ---------------------------------------------------------------------------
 //
 //
 TInt CHnEngine::HandleModelEventL( const TDesC& aEventName,
 CLiwGenericParamList& aParams )
 {
 TInt ret(KErrNotFound);
 if ( aEventName == KNewSuiteLoadedMdEvent )
 {
 // This handles new suite creation, putting its visual model
 // onto the stack eventually.
 ret = HandleNewSuiteLoadedEventL( aParams );
 }
 else if ( aEventName == KBackMdEvent )
 {
 else if (aEventName == KStopEditModeMdEvent )
 {
 // Stopping edit mode
 iControllerInterface.NotifyUiRefreshL( EStopEditMode );
 ret = KErrNone;
 }
 else if (aEventName == KSetFocusEvent )
 {
 // SetFocus
 ret = HandleSetFocusEventL( aParams );
 }
-else if (aEventName == KZoomLarge )
-{
-// Stopping edit mode
-iControllerInterface.NotifyUiRefreshL( EZoomLarge );
-ret = KErrNone;
-}
-else if (aEventName == KZoomSmall)
-		{
-		// Stopping edit mode
-		iControllerInterface.NotifyUiRefreshL( EZoomSmall );
-		ret = KErrNone;
-		}
-else if (aEventName == KZoomNormal )
-{
-// Stopping edit mode
-iControllerInterface.NotifyUiRefreshL( EZoomNormal );
-ret = KErrNone;
-}
 else if (aEventName == KAppGainForeground )
 	{
 	//force matrix gain foreground
 DEBUG(("_MM_:CHnEngine::HandleModelEventL EForegroundGain"));
 iControllerInterface.NotifyUiRefreshL( EForegroundGain );
 	//force matrix gain background
 DEBUG(("_MM_:CHnEngine::HandleModelEventL EBackgroundGain"));
 iControllerInterface.NotifyUiRefreshL( EBackgroundGain );
 ret = KErrNone;
 	}
 return ret;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::HandleWidgetChangeL(
 CLiwGenericParamList& aParams )
 {
 THnSuiteWidgetType type = EChangeWidget;
 TInt pos( 0 );
 const TLiwGenericParam* param = NULL;
 param = aParams.FindFirst( pos,  KWidgetTypeAttrName8 );
 if ( pos != KErrNotFound )
 {
 TPtrC widgetType( KNullDesC );
 param->Value().Get( widgetType );
 if ( widgetType.Compare( KWidgetTypeList ) == 0 )
 type = EListWidget;
 else if ( widgetType.Compare( KWidgetTypeGrid ) == 0 )
 type = EGridWidget;
 else if ( widgetType.Compare( KWidgetTypeCoverFlow ) == 0 )
 type = ECoverFlowWidget;
 }
 CHnSuiteModel* model  = iSuiteContainer->GetLastSuiteModel();
 return HandleWidgetChangeL( model->SuiteName(), type );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::HandleWidgetChangeL( const TDesC& aSuiteName,
 THnSuiteWidgetType aType )
 {
 DEBUG(("_MM_:CMatrixMenuAppUi::HandleWidgetChangeL IN"));
 TInt ret( KErrGeneral );
 CHnRepositoryManager* rep = CHnRepositoryManager::NewLC();
 THnSuiteWidgetType type( EUnspecified );
 TInt err( rep->ReadSuiteWidgetTypeL( aSuiteName, type ) );
 if( ( !err || err == KErrNotFound ) && type != EUnspecified )
 {
 ret = rep->StoreSuiteWidgetTypeL( aSuiteName, aType );
 }
 CleanupStack::PopAndDestroy( rep );
 DEBUG(("_MM_:CMatrixMenuAppUi::HandleWidgetChangeL OUT"));
 return ret;
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::HandleReevaluateEventL(
 CLiwGenericParamList& aParams )
 {
 TInt ret(KErrNone);
 // Paths to retrieve filter values
 _LIT8( KGenreGlobalPath, "filter:genre");
 _LIT8( KIdGlobalPath, "filter:id");
 _LIT8( KGenrePath, "filter:[%d]/genre");
 _LIT8( KItemPath, "filter:[%d]/item");
 CHnFilter* filter = CHnFilter::NewLC();
 TLiwGenericParam param;
 param.PushL();
 aParams.AtL(0, param);
 ASSERT( !param.Name().Compare( KFilterElementItem8 ) );
 TLiwVariant suiteIdVariant;
 suiteIdVariant.PushL();
 TLiwVariant genreVariant;
 genreVariant.PushL();
 TInt idFound =
 HnLiwUtils::GetVariantL( aParams, KIdGlobalPath(), suiteIdVariant );
 TInt found =
 HnLiwUtils::GetVariantL(aParams, KGenreGlobalPath(), genreVariant );
 if (idFound != KErrNotFound)
 {
 filter->SetSuiteId( suiteIdVariant.AsTInt32() );
 filter->SetEvaluateSuiteL( ETrue );
 path.CreateL( KItemPath().Length() );
 path.Format( KItemPath, i );
 TLiwVariant itemVariant;
 HnLiwUtils::GetVariantL(aParams, path, itemVariant );
 CleanupStack::PopAndDestroy( &path );
 TPtrC suiteName;
 TPtrC itemId;
 genreVariant.Get(suiteName);
 itemVariant.Get(itemId);
 CHnItemId* itemIdObject = CHnItemId::NewLC(suiteName, itemId);
 filter->AppendItemIdL( itemIdObject );
 CleanupStack::Pop( itemIdObject );
 genreVariant.Reset();
 itemVariant.Reset();
 }
 }
 CleanupStack::PopAndDestroy( &genreVariant );
 TInt CHnEngine::HandleNewSuiteLoadedEventL(
 CLiwGenericParamList& aParams )
 {
 DEBUG(("_MM_:CHnEngine::HandleNewSuiteLoadedEventL IN"));
 TInt err( KErrNone );
 const TLiwGenericParam* param =
 aParams.FindFirst( err, KNewSuiteParamNameEn );
 if( err != KErrNotFound )
 {
 TPtrC genre;
 param->Value().Get( genre );
 }
 else
 {
 iMetaDataModel->SetModeL( EMdModeNormal );
 }
 TRAP( err, iMetaDataModel->EvaluateL( *filter ) );
 CleanupStack::PopAndDestroy( filter );
 if ( err )
 {
 iMetaDataModel->DeleteLastSuite();
 iSuiteContainer->PopSuiteModelL( genre );
 message = KDebugNoteFileNotFound().AllocL();
 }
 break;
 default :
 {
 message = HBufC::NewL( KDebugNoteOtherError().Length() +
 KMaxLength );
 message->Des().AppendFormat( KDebugNoteOtherError, err );
 }
 break;
 }
 delete message;
 }
 }
 DEBUG(("_MM_:\tReturned error code: %d",err));
 DEBUG(("_MM_:CHnEngine::HandleNewSuiteLoadedEventL OUT"));
 return err;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::HandleSetFocusEventL( const CLiwGenericParamList& aParams  )
 {
 // Triggering event in hierarchy navigator, specifying
 // that suite given by the name genre has been
 DEBUG(("_MM_:CHnEngine::HandleSetFocusEventL IN"));
 TInt posSuite( 0 );
 TInt posItem( 0 );
 	TInt64 suiteCustomId( KErrNotFound );
 	TInt64 itemCustomId( KErrNotFound );
 	// Get suite's and item's custom ids.
 	const TLiwGenericParam* paramSuiteId = aParams.FindFirst( posSuite,  KSuiteCustomId8 );
 	const TLiwGenericParam* paramItemId = aParams.FindFirst( posItem,  KItemCustomId8 );
 	if ( posSuite >= 0 && posItem >= 0 )
 	{
 	suiteCustomId = paramSuiteId->Value().AsTInt64();
 	itemCustomId = paramItemId->Value().AsTInt64();
 	// Get matching suite.
 	CHnSuiteModel* suiteModel = iSuiteContainer->GetMatchingSuiteModel( suiteCustomId );
 	if ( suiteModel )
 		{
 		// If suite is not null, then find matching item model.
 		TInt index( KErrNotFound );
 		CHnItemModel* itemModel = suiteModel->GetMatchingItemModelL( itemCustomId, index );
 		if ( itemModel )
 			{
 			// If itemModel is not null then set highlight and set highligh
 			// on matching item.
 			suiteModel->SetSuiteHighlightL( index );
 		iControllerInterface.HandleSuiteEventL( ESuiteHighlightChanged, suiteModel );
 			}
 		else
 			{
 			suiteModel->QueueFocus( itemCustomId );
 			}
 		}
 	}
 DEBUG(("_MM_:CHnEngine::HandleSetFocusEventL OUT"));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TInt CHnEngine::HandleMoveFocusBeforeDeleteEventL(
 const CLiwGenericParamList& /* aParams */  )
 {
 // Triggering event in hierarchy navigator, specifying
 // that suite given by the name genre has been
 DEBUG(("_MM_:CHnEngine::HandleMoveFocusBeforeDeleteEventL IN"));
 TInt currentHighlight( GetLastSuiteModelL()->GetSuiteHighlight() );
 TInt itemsCount( GetLastSuiteModelL()->GetItemModelsCount() );
 TInt shift( 0 );
 if( AknLayoutUtils::PenEnabled() && iEditMode )
 {
 // add empty item
 shift = 1;
 {
 GetLastSuiteModelL()->SetSuiteHighlightL( currentHighlight + 1 );
 }
 iControllerInterface.HandleSuiteEventL(
 ESuiteHighlightChanged, GetLastSuiteModelL() );
 DEBUG(("_MM_:CHnEngine::HandleMoveFocusBeforeDeleteEventL OUT"));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TInt CHnEngine::InitializeL( CLiwGenericParamList& aParam )
 {
 DEBUG(("_MM_:CMatrixMenuAppUi::InitializeL IN"));
 User::LeaveIfError( HandleNewSuiteLoadedEventL( aParam ) );
 DEBUG(("_MM_:CMatrixMenuAppUi::InitializeL OUT"));
 // This is an interface method so some value has to be returned.
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CHnEngine::ResetModelsL()
 {
 MMPERF(("CHnEngine::ResetModelsL - START"));
 iControllerInterface.NotifyUiRefreshL( ERemoveLiwObjects );
 if( iSuiteContainer )
 {
 iSuiteContainer->RemoveLiwObjects();
 //
 CLiwGenericParamList* CHnEngine::UriQueryToLiwListLC(
 const TDesC8& aUriQuery, const TDesC8& aUriFragment, const TDesC8& aSuiteName )
 {
 CLiwGenericParamList* list = CLiwGenericParamList::NewLC();
 CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 map->PushL();
 RPointerArray< HBufC8 > params = SplitL( aUriQuery, KAnd8 );
 for( TInt i = 0; i < params.Count(); i++ )
 {
 RPointerArray< HBufC8 > paramValue = SplitL( *params[ i ], KEquals8 );
 CleanupResetAndDestroyPushL( paramValue );
 ASSERT( paramValue.Count() == 2 );
 map->InsertL( *paramValue[ 0 ], TLiwVariant( *paramValue[ 1 ] ) );
 CleanupStack::PopAndDestroy( &paramValue );
 }
 if ( aUriFragment.Length() > 0 && aSuiteName.Length() > 0 )
 {
 map->InsertL( KUriHighlight, TLiwVariant( aUriFragment ) );
 map->InsertL( KUriHighlightSuite, TLiwVariant( aSuiteName ) );
 }
 list->AppendL( TLiwGenericParam(  KParams8, TLiwVariant( map )));
 params.ResetAndDestroy();
 CleanupStack::PopAndDestroy( map );
 return list;
 }
 RPointerArray< HBufC8 > CHnEngine::SplitL( const TDesC8& aSource,
 const TDesC8& aSeparator )
 {
 RPointerArray< HBufC8 > tokens;
 CleanupResetAndDestroyPushL( tokens );
 if ( aSource.Length() > 0 && aSeparator.Length() > 0 )
 {
 TPtrC8 tmpSource = aSource;
 TPtrC8 token( KNullDesC8 );
 while( ETrue )
 {
 TInt length = tmpSource.Find( aSeparator );
 if ( length >= 0 )
 {
 token.Set( tmpSource.Mid( 0, length ) );
 tokens.AppendL( token.AllocL() );
 tmpSource.Set( tmpSource.Mid( length + 1 ) );
 {
 iMetaDataModel->SetModeL( EMdModeNormal );
 }
 //The suite on top of the stack is probably displayed.
 //Switching to edit mode has some dramatic ui impact,
 //thus when parts of the suite will get displayed
 //it may look awkward thus the suite on top of the stack
 //is marked as uninitialized, therefore ui will be able to
 //react only to the ready suite model.
 if (AknLayoutUtils::PenEnabled() || (!AknLayoutUtils::PenEnabled() && iEditMode))
 {
 GetLastSuiteModelL()->GetItemsOrder()->MarkSuiteUninitialized();
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CHnEngine::HandleRequestL( const CLiwGenericParamList& aParam,
 CLiwGenericParamList* /*aOutput*/ )
 {
 TInt pos( 0 );
 aParam.FindFirst( pos, KHnRequest );
 if (pos != KErrNotFound)
 //
 void CHnEngine::LoadFromCrL( const TDesC8& aUri )
 	{
 	HBufC8* uriBuf = HBufC8::NewLC( aUri.Length() );
 	uriBuf->Des().Copy( aUri );
 	TUriParser8 parser;
 	parser.Parse( *uriBuf );
 	User::LeaveIfError( parser.IsSchemeValid() ? KErrNone : KErrPathNotFound );
 	const TDesC8& query = parser.Extract( EUriQuery );
 RPointerArray< HBufC8 > params = SplitL( query, HnLogicalRelations::KLogicalAnd8);
 TBuf8<KApaMaxAppGroupName + KTimeStampBufferLength + KUidStringLength + 2> item;
 for( TInt i = 0; i < params.Count(); i++ )
 {
 RPointerArray< HBufC8 > paramValue = SplitL( *params[ i ], HnLogicalRelations::KLogicalEqual8 );
 CleanupResetAndDestroyPushL( paramValue );
 ASSERT( paramValue.Count() == 2 );
 if ( !paramValue[0]->Compare(KMcsAppGroupName8) )
 	{
 	TBuf8<KApaMaxAppGroupName> appgrname;
 	if( paramValue[1]->Length()<=KApaMaxAppGroupName )
 	    {
 item.Append( *paramValue[1] );
 }
 	}
 CleanupStack::PopAndDestroy( &paramValue );
 }
 TBuf<KApaMaxAppGroupName + KTimeStampBufferLength + KUidStringLength + 2> item1;
 item1.Copy(item);
 	CRepository *cenRep = CRepository::NewLC( KCRUidMenu );
 	cenRep->Set(KMenuShowFolder, item1);
 	CleanupStack::PopAndDestroy( cenRep );
 params.ResetAndDestroy();
 CleanupStack::PopAndDestroy( uriBuf );
 	}
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CHnEngine::LightStatusChanged(TInt aTarget,
 CHWRMLight::TLightStatus aStatus)
 {
 }
 DEBUG(("_Mm_:CMmAppUi::LightStatusChanged - OUT"));
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool CHnEngine::HandleActionL( const TDesC8& aUri )
 	{
 	TBool exitActionConsumed(EFalse);
 	HBufC8* uriBuf = HBufC8::NewLC( aUri.Length() );
 	uriBuf->Des().Copy( aUri );
 	TUriParser8 parser;
 parser.Parse( *uriBuf );
 User::LeaveIfError( parser.IsSchemeValid() ? KErrNone : KErrPathNotFound );
 const TDesC8& host8 = parser.Extract( EUriHost );
 const TDesC8& query = parser.Extract( EUriQuery );
 	RBuf action;
 CleanupClosePushL( action );
 CLiwGenericParamList* paramsUri = UriQueryToLiwListLC( query, KNullDesC8, KNullDesC8 );
 HnLiwUtils::GetStringL( *paramsUri, KActionParams, action );
 	TBool exitHideHostNotFound( ETrue  );
 	if( suiteModel  && suiteModel->ExitMode() == EExitModeHide )
 	    {
 	    exitHideHostNotFound = EFalse;
 	    }
 		if ( exitHideHostNotFound )
 			{
 			//send to foreground
 			CLiwGenericParamList* pl = CLiwGenericParamList::NewL();
 			CleanupStack::PushL( pl );
 			CLiwGenericParamList* pl = CLiwGenericParamList::NewL();
 			CleanupStack::PushL( pl );
 			HandleModelEventL( KAppGainBackground, *pl );
 			CleanupStack::PopAndDestroy( pl );
 			}
 	if ( exitHideHostNotFound && iSuiteContainer->GetLastSuiteModel() == suiteModel  )
 		{
 HandleBackEventL( host,  1 );
 		}
 	else
 		{
 	//reset to root
 CLiwGenericParamList* params = CLiwGenericParamList::NewLC();
 params->AppendL( iMetaDataModel->GetSuiteParameters( 0 ) );
 	ResetModelsL();
 InitializeL( *params );
 CleanupStack::PopAndDestroy( params );
 		}
 	CleanupStack::PopAndDestroy( &host );
 	exitActionConsumed = ETrue;
 	}
 CleanupStack::PopAndDestroy( paramsUri );
 CleanupStack::PopAndDestroy( &action );
 CleanupStack::PopAndDestroy( uriBuf );
 return exitActionConsumed;
 	}
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CHnEngine::LoadSuitesL( const TDesC8& aUri )
 	{
 	TBool sendToForeground(EFalse);
 	HBufC8* uriBuf = HBufC8::NewLC( aUri.Length() );
 	uriBuf->Des().Copy( aUri );
 	TUriParser8 parser;
 	parser.Parse( *uriBuf );
 	User::LeaveIfError( parser.IsSchemeValid() ? KErrNone : KErrPathNotFound );
 	CDesC8ArrayFlat* suiteNameArray = new( ELeave ) CDesC8ArrayFlat( KDefaultGranularity ) ;
 	CleanupStack::PushL( suiteNameArray );
 	const TDesC8& host = parser.Extract( EUriHost );
 RBuf8 host8;
 CleanupClosePushL( host8 );
 if (host.Compare( KNullDesC8 ))
 {
 		path8->Des().Copy( path );
 		path8->Des().LowerCase();
 		ParseSuiteUriPathL( *path8, *suiteNameArray );
 		CleanupStack::PopAndDestroy( path8 );
 		}
 	TBool suiteExists( EFalse );
 	iMetaDataModel->IgnoreEvaluations( ETrue );
 	iMetaDataModel->QueueForeground( CHnMdModel::EWhenAnySuiteIsEvaluated );
 if( host8.Length() == 0 || ( host8.Length() > 0 &&
 !iMetaDataModel->SuiteModelExistsL( host8 ) ) )
 {
 suiteNameArray->Reset();
 suiteNameArray->AppendL( KRoot8 );
 }
 	for( TInt i = 0; i < suiteNameArray->Count(); ++i )
 		{
 		suiteExists = iMetaDataModel->SuiteModelExistsL(
 			( *suiteNameArray )[i] );
 		TBool nextExists = i < suiteNameArray->Count() - 1 &&
 			iMetaDataModel->SuiteModelExistsL( ( *suiteNameArray )[i + 1] );
 		TBool isLast = ( i == ( suiteNameArray->Count() - 1 ) );
 		TBool turnOnEvaluation = ( suiteExists && ( !nextExists || isLast ) );
 		if( turnOnEvaluation || !suiteExists )
 			{
 			iMetaDataModel->IgnoreEvaluations( EFalse );
 			}
 		TInt err( KErrNone );
 		// Ignore loading new suite if the last suite in model is the same
 		// as first one in the uri.
 		if ( i == 0 )
 				HandleTheSameSuitesL( nextExists, parser.Extract( EUriQuery ) );
 				sendToForeground = ETrue;
 				continue;
 				}
 			}
 		if( suiteExists )
 			{
 			if (!nextExists)
 			    {
 			    // Tricky: queue foreground so that if the suite is evaluated synchronously
 				( *suiteNameArray )[i], parser.Extract( EUriQuery ), parser.Extract( EUriFragment ) );
 			if ( KErrNone == err && !nextExists && iMetaDataModel->IsForegroundQueued() )
 			    {
 			    // Tricky: if foreground is still queued it means that the suite is evaluated
 			    // asynchronously. Override the previos foreground queue setting with one
 			    // that will be effective only if the last loaded suite is evaluated.
 			    iMetaDataModel->QueueForeground( CHnMdModel::EWhenCurrentTopSuiteIsEvaluated );
 			    }
 			if ( err != KErrNone )
 				{
 				sendToForeground = ETrue;
 				}
 			}
 		if( !suiteExists || err != KErrNone || !nextExists )
 			{
 			CHnFilter* filter = CHnFilter::NewLC();
 			filter->SetSuiteId(
 				iSuiteContainer->GetLastSuiteModel()->CustomId() );
 			filter->SetEvaluateSuiteL( ETrue );
 			iMetaDataModel->IgnoreEvaluations( EFalse );
 			TRAPD( err, iMetaDataModel->EvaluateL( *filter ) );
 			CleanupStack::PopAndDestroy( filter );
 			if( err )
 				{
 				iMetaDataModel->DeleteLastSuite();
 				iSuiteContainer->PopSuiteModelL(
 				sendToForeground = ETrue;
 				}
 			break;
 			}
 		}
 	// set highlight only when path is valid!
 	if( suiteExists )
 		{
 		HighlightPlacementFromUriL( parser.Extract( EUriFragment ) );
 		}
 CleanupStack::PopAndDestroy( &host8 );
 	CleanupStack::PopAndDestroy( suiteNameArray );
 	CleanupStack::PopAndDestroy( uriBuf );
 //    send to foreground
 	if ( sendToForeground )
 		{
 		CLiwGenericParamList* pl = CLiwGenericParamList::NewL();
 		CleanupStack::PushL( pl );

changeset 1	5315654608de
parent 0	f72a12da539e
child 26	1b758917cafc