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

equal deleted inserted replaced

-:3321d3e205b6
+:b01126ce0bec
 //
 // ---------------------------------------------------------------------------
 //
 EXPORT_C void CHnEngine::LoadSuitesFromUriL( const TDesC8& aUri )
 {
 DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL IN"));
 DEBUG8(("_MM_:\tURI: %S",&aUri));
-TBool consumed(EFalse);
+TBool consumed( EFalse );
-if ( aUri.Find( KSetFocusWithPref ) != KErrNotFound )
+if( aUri.Find( KSetFocusWithPref ) != KErrNotFound )
 {
 LoadFromCrL( aUri );
 consumed = ETrue;
 }
+else if( aUri.Find( KOpenItemWithPref ) != KErrNotFound )
-if ( !consumed )
+{
-{
+LoadItemFromCrL( aUri );
-consumed = HandleActionL( aUri );
+consumed = ETrue;
 }
-if ( !consumed )
+if( !consumed )
 {
-LoadSuitesL( aUri );
+consumed = HandleActionL( aUri );
 }
+if( !consumed )
+{
+LoadSuitesL( aUri );
+}
 DEBUG(("_MM_:CHnEngine::LoadSuitesFromUriL OUT"));
 }
 // ---------------------------------------------------------------------------
 // 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 );
 CleanupResetAndDestroyPushL( tokens );
 if ( aSource.Length() > 0 && aSeparator.Length() > 0 )
 {
 TPtrC8 tmpSource = aSource;
 TPtrC8 token( KNullDesC8 );
 while( ETrue )
 {
 TInt length = tmpSource.Find( aSeparator );
 if( aSeparator == HnLogicalRelations::KParamUid8
 && length != KErrNotFound )
 {
 TInt ampPos( KErrNotFound );
-TInt eqPos( KErrNotFound );
 do
 {
 ampPos = tmpSource.Mid(
 length + HnLogicalRelations::KParamUid8().Length() ).
 Find( HnLogicalRelations::KLogicalAnd8 );
 length += (ampPos + HnLogicalRelations::KParamUid8().Length());
 ampPos = 0;
 }
 else if( (length + HnLogicalRelations::KParamUid8().Length())
 == tmpSource.Length())
 {
 length = KErrNotFound;
 }
 }while( !ampPos );
 }
 User::LeaveIfError( parser.IsSchemeValid() ? KErrNone : KErrPathNotFound );
 const TDesC8& query = parser.Extract( EUriQuery );
 RPointerArray< HBufC8 > params = SplitL( query, HnLogicalRelations::KParamUid8);
-TBuf8<KApaMaxAppGroupName + KTimeStampBufferLength + KUidStringLength + 2> item;
+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;
+TBuf8< KApaMaxAppGroupName > appgrname;
-	if( paramValue[1]->Length()<=KApaMaxAppGroupName )
+if( paramValue[1]->Length()<= KApaMaxAppGroupName )
-	    {
+{
-	    appgrname.Append( *paramValue[1] );
+appgrname.Append( *paramValue[1] );
-	    }
+}
 //get current time
 TTime currentTime;
 currentTime.HomeTime();
 TDateTime date(currentTime.DateTime());
 }
 }
 CleanupStack::PopAndDestroy( &paramValue );
 }
-TBuf<KApaMaxAppGroupName + KTimeStampBufferLength + KUidStringLength + 2> item1;
+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 );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool CHnEngine::HandleActionL( const TDesC8& aUri )
 {
-TBool exitActionConsumed(EFalse);
+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 );
-if ( !action.Compare( KActionExit ) )
+if( !action.Compare( KActionExit ) )
 {
 RBuf host;
 host.CreateL( host8.Length() );
 CleanupClosePushL( host );
-host.Copy(host8);
+host.Copy( host8 );
 CHnSuiteModel* suiteModel = iSuiteContainer->GetSuiteModel( host );
-TBool exitHideHostNotFound( ETrue  );
+TBool exitHideHostNotFound( ETrue );
-if( suiteModel  && suiteModel->ExitMode() == EExitModeHide )
+if( suiteModel && suiteModel->ExitMode() == EExitModeHide )
 {
 exitHideHostNotFound = EFalse;
 }
-if ( exitHideHostNotFound )
+if( exitHideHostNotFound )
 {
 //send to foreground
 CLiwGenericParamList* pl = CLiwGenericParamList::NewL();
 CleanupStack::PushL( pl );
 HandleModelEventL( KAppGainForeground, *pl );
 CleanupStack::PopAndDestroy( pl );
 }
 else
 {
 //send to background
 CLiwGenericParamList* pl = CLiwGenericParamList::NewL();
 CleanupStack::PushL( pl );
 HandleModelEventL( KAppGainBackground, *pl );
 CleanupStack::PopAndDestroy( pl );
 }
-if ( exitHideHostNotFound && iSuiteContainer->GetLastSuiteModel() == suiteModel  )
+if( exitHideHostNotFound && iSuiteContainer->GetLastSuiteModel() == suiteModel )
 {
-HandleBackEventL( host,  1 );
+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 ))
 {
 host8.CreateL( host );
 host8.LowerCase();
 suiteNameArray->AppendL( host8 );
 DEBUG8(( "_MM_:\tURI host part: %S", &host8 ));
 }
 const TDesC8& path = parser.Extract( EUriPath );
 if (path.Compare( KNullDesC8 ))
 {
 HBufC8* path8 = HBufC8::NewLC( path.Length() );
 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 )
 {
 if ( SuitesAreTheSameL( iMetaDataModel->GetLastSuite()->SuiteName(), (*suiteNameArray)[i] ) )
 {
 HandleTheSameSuitesL( nextExists, parser.Extract( EUriQuery ) );
 sendToForeground = ETrue;
 continue;
 }
 }
+if( suiteExists )
+{
+if (!nextExists)
+{
+// Tricky: queue foreground so that if the suite is evaluated synchronously
+// the foreground will be gained.
+iMetaDataModel->QueueForeground( CHnMdModel::EWhenAnySuiteIsEvaluated );
+}
+err = LoadSuiteFromUriL(
+( *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(
+HnConvUtils::Str8ToStr( ( *suiteNameArray )[i] )->Des() );
+sendToForeground = ETrue;
+}
+break;
+}
+}
+// set highlight only when path is valid!
 if( suiteExists )
 {
-if (!nextExists)
+HighlightPlacementFromUriL( parser.Extract( EUriFragment ) );
-{
+}
-// Tricky: queue foreground so that if the suite is evaluated synchronously
-// the foreground will be gained.
-iMetaDataModel->QueueForeground( CHnMdModel::EWhenAnySuiteIsEvaluated );
-}
-err = LoadSuiteFromUriL(
-( *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(
-HnConvUtils::Str8ToStr( ( *suiteNameArray )[i] )->Des() );
-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 );
 HandleModelEventL( KAppGainForeground, *pl );
 CleanupStack::PopAndDestroy( pl );
 iMetaDataModel->QueueForeground( CHnMdModel::ENever );
 }
 }
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHnEngine::LoadItemFromCrL( 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 );
+if( query.Compare( KNullDesC8 ) )
+{
+TBuf8<KMaxLength> item;
+RPointerArray<HBufC8> paramValue = SplitL( query,
+HnLogicalRelations::KLogicalEqual8 );
+CleanupResetAndDestroyPushL( paramValue );
+ASSERT( paramValue.Count() == 2 );
+if( !paramValue[0]->Compare( KId8 ) )
+{
+if( paramValue[1]->Length() <= KUidStringLength )
+{
+item.Append( *paramValue[1] );
+}
+}
+CleanupStack::PopAndDestroy( &paramValue );
+TBuf<KMaxLength> item1;
+item1.Copy( item );
+CRepository *cenRep = CRepository::NewLC( KCRUidMenu );
+cenRep->Set( KMenuOpenItem, item1 );
+CleanupStack::PopAndDestroy( cenRep );
+}
+CleanupStack::PopAndDestroy( uriBuf );
+}
 // End of file

branch	RCL_3
changeset 93	b01126ce0bec
parent 88	3321d3e205b6
child 102	ba63c83f4716