FCL/sf/app/musicplayer: comparison mpxplugins/viewplugins/views/collectionviewhg/src/mpxcollectionviewhgcontainer.cpp

equal deleted inserted replaced

-:c54d95799c80
+:a1247965635c
 #include "mpxcollectionviewhgplaylisthelper.h"
 #include "mpxcollectionviewhgtnloader.h"
 #include "mpxcbahandler.h"
 #include "mpxselectedalbumhandler.h"
 #include "mpxpopuplist.h"
+#include "mpxcollectionviewhgswitchbuffer.h"
 // CONSTANTS
 _LIT( KMPXCollectionViewRscPath, "mpxcollectionviewhg.rsc" );
 _LIT( KMPXCollectionViewIconFile, "mpxcollectionviewhg.mbm" );
 const TInt KMPXListSelectionCount = 5;
 #endif
 // Added by Harri. Buffer size has to be smaller with mediawall, otherwise IVE3 runs out of memory
 #ifdef __WINS__
 const TInt KMPXListBufferSizeWithMediaWall = 20;
 #else
-const TInt KMPXListBufferSizeWithMediaWall = 80;
+const TInt KMPXListBufferSizeWithMediaWall = 40;
 #endif
 const TInt KMPXMaxFileLength = 256;
 const TReal KIconFactor = 0.7;
 const TInt KThumbLoadingPauseForTransition(500000);
 MPX_FUNC( "CMPXCollectionViewHgContainer::MopSupplyObject" );
 if( aId.iUid == MAknsControlContext::ETypeId && iBgContext )
 {
 return MAknsControlContext::SupplyMopObject(aId, iBgContext );
 }
 return CCoeControl::MopSupplyObject(aId);
 	}
 // ---------------------------------------------------------------------------
 // Sets playback status
 TRect clientRect = ((CAknView*)iView)->ClientRect();
 SetRect( clientRect );
 iBgContext->SetRect(((CAknAppUi*)iCoeEnv->AppUi())->ApplicationRect());
 // call HandleLbxItemAdditionL
 HandleLbxItemAdditionL();
 }
 );
 if(iMediaWall)
 TInt count( mediaArray.Count() );
 MPX_DEBUG2( "CMPXCollectionViewHgContainer::HandleLbxItemAdditionL count=%d", count);
 HandleLbxItemRemovalL();
 TViewType prevViewType = iCurrentViewType;
 ResolveCurrentViewType( count );
 iThumbnailReqMap.Reset();
 if (ShuffleItemPresent())
 iShuffleItem = 1;
 else
 	iShuffleItem = 0;
 // MediaWall sets the default icon in the construction phase.
 iDefaultIconSet = EFalse;
 if( !iLayoutSwitch  )
 {
-			// We only need to use this for one transition coming
+// We only need to use this for one transition coming
-			// from playback view.
+// from playback view.
-			TBool pbv = (iPreviousViewId == TUid::Uid(KMPXPluginTypePlaybackUid)) ? ETrue : EFalse;
+TBool pbv = (iPreviousViewId == TUid::Uid(KMPXPluginTypePlaybackUid)) ? ETrue : EFalse;
-			if ( pbv )
+if ( pbv )
-				{
+{
 	iPreviousViewId = TUid::Uid(0);
-				}
+}
 BeginFullScreenAnimation( pbv );
 }
 switch (iCurrentViewType)
 {
 case EMPXViewMediawall:
 {
 TMPXPlaybackState pbState( iPlaybackUtility->StateL() );
-if ( pbState == EPbStatePlaying || pbState == EPbStatePaused )
+if ( pbState == EPbStatePlaying || pbState == EPbStatePaused || pbState == EPbStateStopped )
+{
 RestoreSelectedAlbumItemL(mediaArray);
+}
 PrepareMediaWallL(mediaArray, count);
 iOpenAlbumTracks = EFalse;
 break;
 }
 case EMPXViewTBone:
 {
 RestoreSelectedAlbumItemL(mediaArray);
 PrepareMediaWallWithListL( mediaArray, count );
-				// We need to adjust the CBA for this view.
+// We need to adjust the CBA for this view.
-				if( iCbaHandler )
+if( iCbaHandler )
-					iCbaHandler->UpdateCba();
+{
+iCbaHandler->UpdateCba();
+}
 break;
 }
 case EMPXViewList:
 {
 PrepareListL(mediaArray, count);
 //
 void CMPXCollectionViewHgContainer::ResizeListL(const CMPXMediaArray& aMediaArray, TInt aCount)
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::ResizeListL" );
 TInt mediaCount = aMediaArray.Count();
 if( iListWidget )
 {
 TRect clientRect = ((CAknView*)iView)->ClientRect();
 TInt mediaIndex = MediaIndex(iListWidget->SelectedIndex());
+mediaIndex = ( KErrNotFound == mediaIndex ) ? iListWidget->FirstIndexOnScreen() : mediaIndex;
 mediaIndex = ( mediaIndex >= 0 && (mediaIndex < (mediaCount)) ) ? mediaIndex : (mediaCount - 1);
 TInt prevItemCount = iListWidget->ItemCount();
 iListWidget->InitScreenL( clientRect );
 iListWidget->Reset();
 if ( aCount )
 {
 // enable scroll buffering now as it has not been enabled when empty list was constructed
 if ( !prevItemCount )
 {
 iListWidget->EnableScrollBufferL( *this, KMPXListBufferSize, KMPXListBufferSize/4 );
 }
 iListWidget->ResizeL( aCount );
 ProvideDataWithoutThumbnailsL(aMediaArray);
 iListWidget->SetSelectedIndex( mediaIndex + iShuffleItem );
 }
 else if( iMediaWall )
 {
 // In case of mediawall components we switch to different view type if orientation changes
 // so there is no need to set new client rect for mediawall.
 TInt mediaIndex = MediaIndex(iMediaWall->SelectedIndex());
 // Correct the array index if it is out of range
 // This case may happen when last album or album beside selected album is deleted
 		// mediaIndex -1 is valid and it represents shuffle item
 if ( mediaIndex >= mediaCount || mediaIndex < -1)
 {
 mediaIndex = mediaCount - 1; // last item of the list
 }
 //in case of shuffle item is seleted (mediaIndex -1), there is no need to save it.
 if( (iSelectedAlbumIndex != mediaIndex) && ( mediaIndex != -1) )
 {
 iSelectedAlbumIndex = mediaIndex;
 SaveSelectedAlbumItemL( iSelectedAlbumIndex );
 }
 iMediaWall->Reset();
 if ( aCount )
 {
 iMediaWall->ResizeL( aCount );
 ProvideDataWithoutThumbnailsMwL(aMediaArray);
 iMediaWall->SetSelectedIndex( mediaIndex + iShuffleItem);
 if ( iCurrentViewType == EMPXViewTBone )
 {
 OpenAlbumL( mediaIndex );
 }
 // ----------------------------------------------------------------------------
 void CMPXCollectionViewHgContainer::PrepareListL(const CMPXMediaArray& aMediaArray, TInt aCount)
 {
 MPX_FUNC("CMPXCollectionViewHgContainer::PrepareListL");
-	if (!((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->IsVisible())
+if (!((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->IsVisible())
-		((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->MakeVisible(ETrue);
+((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->MakeVisible(ETrue);
-	if( iCbaHandler )
+if( iCbaHandler )
-	    iCbaHandler->UpdateCba();
+iCbaHandler->UpdateCba();
 TRect clientRect = ((CAknView*)iView)->ClientRect();
 iThumbnailManager->SetSizeL( EAudioListThumbnailSize );
 iImageSize = CHgDoubleGraphicListFlat::PreferredImageSize();
 if( !iListWidget )
 {
 iListWidget = CHgDoubleGraphicListFlat::NewL (
 clientRect,
 aCount,
 NULL,
 NULL );
 iListWidget->SetMenuProviderL(this);
 iListWidget->SetSelectionObserver(*this);
 // TODO. check if this is correct for all lists
 iListWidget->ClearFlags( CHgScroller::EHgScrollerKeyMarkingDisabled );
 iListWidget->SetFocus(ETrue);
 ProvideDataWithoutThumbnailsL(aMediaArray);
 iListWidget->MakeVisible(ETrue);
 iListWidget->InitScreenL(clientRect);
 }
-if ( (iAlbumIndex > 0) && (iAlbumIndex < aCount) )
+if ( (iAlbumIndex >= 0) && (iAlbumIndex < aCount) )
 {
 iListWidget->SetSelectedIndex( iAlbumIndex + iShuffleItem );
 }
+else if ( KErrNotFound == iAlbumIndex )
+{
+if ( iSelectedAlbumIndex >= 0 && iSelectedAlbumIndex < aCount)
+{
+iListWidget->SetSelectedIndex( iSelectedAlbumIndex + iShuffleItem );
+}
+else
+{
+iListWidget->SetSelectedIndex( iListWidget->FirstIndexOnScreen() + iShuffleItem );
+}
+}
 // TODO. Define here in which views we need to have buffering enabled in the list
 if( ( ( iContext == EContextGroupAlbum ) ||
 ( iContext == EContextGroupArtist ) ||
 ( iContext == EContextGroupSong ) ||
-		( iContext == EContextItemGenre ) ||
+( iContext == EContextItemGenre ) ||
 ( iContext == EContextItemPlaylist ) ) &&
 // Check if the list is empty, Enable scroll buffer won't call requst if list is empty
 ( iListWidget->ItemCount() != 0 ) )
 {
 MPX_DEBUG1("CMPXCollectionViewHgContainer::PrepareListL - EnableScrollBufferL");
-iListWidget->EnableScrollBufferL( *this, KMPXListBufferSize, KMPXListBufferSize/4 );
+iListWidget->EnableScrollBufferL(*this, KMPXListBufferSize, KMPXListBufferSize/4);
 }
 else
 {
 EndFullScreenAnimation();
 iListWidget->RefreshScreen(0);
 // get front rectange from layout
 TAknLayoutRect frontRect;
 frontRect.LayoutRect( appRect, AknLayoutScalable_Apps::cf0_flow_pane_g1(0) );
 	iImageSize = frontRect.Rect().Size();
+	CMPXCollectionViewHgSwitchBuffer* switchBuffer(NULL);
+if( iListWidget && (iPrevContext == EContextGroupAlbum || iPrevContext == EContextItemAlbum ) )
+{
+switchBuffer = CMPXCollectionViewHgSwitchBuffer::CreateBufferLC( *iListWidget );
+}
+else if ( iMediaWall )
+{
+switchBuffer = CMPXCollectionViewHgSwitchBuffer::CreateBufferLC( *iMediaWall );
+switchBuffer->SetIndexOffset(1);
+}
 if( iMediaWall )
 {
 delete iMediaWall;
 iMediaWall = 0;
 delete iMwListWidget;
 		}
 iMediaWall->SetOpenedItemRect( iPopupListRect );
 iMediaWall->SetOpeningAnimationType( CHgVgMediaWall::EHgVgOpeningAnimationZoomToFront );
+if( switchBuffer )
+{
+switchBuffer->FillFromBufferL( *iMediaWall );
+CleanupStack::PopAndDestroy( switchBuffer );
+switchBuffer = NULL;
+}
 	iDefaultIconSet = ETrue;
 }
 // ----------------------------------------------------------------------------
 // Add shuffle list item to the top of the list.
 // ----------------------------------------------------------------------------
 TBool CMPXCollectionViewHgContainer::IsTBoneView()
 {
 TBool tBoneView = EFalse;
-if( EMPXViewTBone == iCurrentViewType )
+if( EMPXViewTBone == iCurrentViewType || iOpenAlbumTracks )
 tBoneView = ETrue;
 return tBoneView;
 }
 }
 default:
 iCurrentViewType = EMPXViewList;
 break;
 }
 // if tbone view is empty, switch back to Albums list or meidawall view
 if( ( iCurrentViewType == EMPXViewTBone ) && ( aCount < 1 ) )
 {
 if( landscapeOrientation )
 iCurrentViewType = EMPXViewMediawall;
 else
 iCurrentViewType = EMPXViewList;
 }
 }
 // ----------------------------------------------------------------------------
 // Clears the previous view content.
 // ----------------------------------------------------------------------------
 if (!ShufflePlayAllL(index))
 {
 switch( iContext )
 {
 case EContextGroupAlbum:
 case EContextItemAlbum:
 {
 iSelectedAlbumIndex = index;
 SaveSelectedAlbumItemL(index);
 // Open first song of album & playlist for entire album is created.
 PlayAlbumL(index);
 break;
 }
 case EContextGroupPlaylist:
 {
 PlayPlaylistL(index);
 if( iCurrentViewType == EMPXViewTBone && iSelectedAlbumIndex != index )
 {
 if ( aControl == iMediaWall )
 {
 iSelectedAlbumIndex = index;
 iAlbumIndex = index;
 OpenAlbumL(index);
 }
 }
 else if( iCurrentViewType == EMPXViewMediawall )
 {
 if ( iContext == EContextGroupAlbum )
 {
 TBool landscapeOrientation = Layout_Meta_Data::IsLandscapeOrientation();
 if ( landscapeOrientation )
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MEDIAWALL_ARTIST_UNKNOWN );
 }
 else
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MP_LIST_ARTIST_UNKNOWN );
 }
 }
 else
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MEDIAWALL_ARTIST_UNKNOWN );
 }
 aVisualItem->SetTitleL( *unknownText );
 CleanupStack::PopAndDestroy( unknownText );
 }
 }
 void CMPXCollectionViewHgContainer::SetDetailCountL(
 CHgItem* aVisualItem,
 CMPXMedia* aMedia )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::SetDetailCountL" );
-if ( aMedia->IsSupported( KMPXMediaGeneralCount ) )
+	if ( aMedia->IsSupported( KMPXMediaGeneralCount ) )
-{
+		{
-TInt count( aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralCount ) );
+		TInt count( aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralCount ) );
 if ( iContext == EContextGroupGenre )
 {
 HBufC* numSongsText = NULL;
 if ( count > 1 || count == 0 )
 {
 numSongsText = StringLoader::LoadLC( R_MPX_MUSIC_NUM_SONGS, count );
 }
 else
 {
 numSongsText = StringLoader::LoadLC( R_MPX_MUSIC_ONE_SONG );
 }
 TPtr ptr = numSongsText->Des();
 AknTextUtils::LanguageSpecificNumberConversion( ptr );
 aVisualItem->SetTextL( ptr );
 CleanupStack::PopAndDestroy( numSongsText );
 {
 detailText.Copy( album.Left(detailText.MaxLength()));
 aVisualItem->SetTextL( detailText );
 }
 else
 {
 HBufC* unknownText = NULL;
 if ( iContext == EContextGroupAlbum )
 {
 TBool landscapeOrientation = Layout_Meta_Data::IsLandscapeOrientation();
 if ( landscapeOrientation )
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MEDIAWALL_ALBUM_UNKNOWN );
 }
 else
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MP_LIST_ALBUM_UNKNOWN );
 }
 }
 else
 {
 unknownText =
 StringLoader::LoadLC( R_MPX_MEDIAWALL_ALBUM_UNKNOWN );
 }
 aVisualItem->SetTextL( *unknownText );
 CleanupStack::PopAndDestroy( unknownText );
 }
 }
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::SetDetailDurationL" );
 if ( iContext == EContextGroupPlaylist &&
 aMedia->IsSupported( KMPXMediaGeneralDuration ) &&
 	     aMedia->IsSupported( KMPXMediaGeneralCount ) )
-{
+		{
-TBuf<KMPXMaxFileLength> detailText;
+		TBuf<KMPXMaxFileLength> detailText;
-TInt count( aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralCount ) );
+		TInt count( aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralCount ) );
-TInt duration = aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralDuration );
+		TInt duration = aMedia->ValueTObjectL<TInt>( KMPXMediaGeneralDuration );
 UpdateTimeIndicatorsL(detailText, duration);
 HBufC* numSongsDurationText = NULL;
 	if ( count > 1 || count == 0 )
 	    {
 	    numSongsDurationText = StringLoader::LoadLC( R_MPX_MUSIC_NUM_SONGS_DURATION, detailText, count );
 	    }
 	else
 	    {
 	    numSongsDurationText = StringLoader::LoadLC( R_MPX_MUSIC_ONE_SONG_DURATION, detailText );
 	    }
 TPtr ptr = numSongsDurationText->Des();
 AknTextUtils::LanguageSpecificNumberConversion( ptr );
 aVisualItem->SetTextL( ptr );
 CleanupStack::PopAndDestroy( numSongsDurationText );
 }
 else if ( iContext == EContextItemPodcast &&
 aMedia->IsSupported( KMPXMediaGeneralDuration ) &&
 const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
 const TInt count( mediaArray.Count() );
 if ( count > 1 && iContext == EContextGroupAlbum )
 {
 TBool landscapeOrientation = Layout_Meta_Data::IsLandscapeOrientation();
 if ( landscapeOrientation )
 {
 HBufC* shuffleText = StringLoader::LoadLC(
 R_MPX_MEDIAWALL_TITLE_SHUFFLE_ALL );
 aItem->SetTitleL( *shuffleText );
 CleanupStack::PopAndDestroy( shuffleText );
 }
 else
 {
 HBufC* shuffleText = StringLoader::LoadLC(
 R_MPX_SHUFFLE );
 aItem->SetTitleL( *shuffleText );
 CleanupStack::PopAndDestroy( shuffleText );
 }
 // We can try to set icon too.
 SetDetailIconShuffleL();
 res = ETrue;
 }
 {
 HBufC* shuffleText = StringLoader::LoadLC(
 R_MPX_SHUFFLE );
 aItem->SetTitleL( *shuffleText );
 CleanupStack::PopAndDestroy( shuffleText );
 // We can try to set icon too.
 SetDetailIconShuffleL();
 res = ETrue;
 }
 void CMPXCollectionViewHgContainer::SetCollectionContextL()
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::SetCollectionContextL" );
 const CMPXMedia& media = iListBoxArray->ContainerMedia();
 if ( NULL == &media )
 {
 MPX_DEBUG1( "CMPXCollectionViewHgContainer::SetCollectionContextL NO media");
 User::Leave(KErrNotFound);
 }
 TMPXGeneralType containerType( EMPXNoType );
 if ( media.IsSupported( KMPXMediaGeneralType ) )
 {
 containerType = media.ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
 }
 // Shows the album songs in songs dialog.
 // -----------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::ShowAlbumSongsDialogL( const CMPXMedia& aResults )
 {
-CAknSinglePopupMenuStyleListBox* listBox = new ( ELeave ) CAknSinglePopupMenuStyleListBox;
+CAknSingleGraphicPopupMenuStyleListBox* listBox = new ( ELeave ) CAknSingleGraphicPopupMenuStyleListBox;
 CleanupStack::PushL( listBox );
 CAknPopupList* dialog = CAknPopupList::NewL(listBox, R_MPX_COLLECTION_ALBUMSONGS_LIST_CBA,
 AknPopupLayouts::EDynMenuWindow );
 if ( songCount > 1 )
 {
 HBufC* shuffleText = StringLoader::LoadLC(
 R_MPX_MEDIAWALL_DIALOG_SHUFFLE );
-songList->AppendL( *shuffleText );
+// Make room for 3 more formatting characters.
+		HBufC* finalText = HBufC::NewLC(shuffleText->Length() + 3);
+		TPtr ptr = finalText->Des();
+		// This tells the list to use icon at index 0 of array index.
+		ptr.Append(_L("0\t"));
+		ptr.Append(shuffleText->Des());
+songList->AppendL( *finalText );
+CleanupStack::PopAndDestroy( finalText );
 CleanupStack::PopAndDestroy( shuffleText );
+		CAknIconArray* iconArray = new( ELeave ) CAknIconArray( 1 );
+		CleanupStack::PushL( iconArray );
+		// Prepare icon array.
+		CGulIcon* icon = (*iIconArray)[EMPXClvIconShuffle];
+		CGulIcon* iconCopy = CGulIcon::NewL(icon->Bitmap(), icon->Mask());
+		iconCopy->SetBitmapsOwnedExternally(ETrue);
+		iconArray->AppendL(iconCopy);
+		listBox->ItemDrawer()->ColumnData()->SetIconArrayL( iconArray );
+		CleanupStack::Pop(); // iconArray
 }
 for ( TInt i = 0; i < songCount; i++ )
 {
 // Just get the exiting item and update the fields + icon.
 break;
 }
 if ( currentMedia->IsSupported( KMPXMediaGeneralTitle ) )
 {
 const TDesC& title = currentMedia->ValueText( KMPXMediaGeneralTitle );
-songList->AppendL( title );
+			HBufC* finalText = HBufC::NewLC(title.Length() + 2);
+			TPtr ptr = finalText->Des();
+ptr.Append(_L("\t"));
+ptr.Append(title);
+songList->AppendL( *finalText );
+	CleanupStack::PopAndDestroy( finalText );
 }
 }
 CTextListBoxModel* model = listBox->Model();
 model->SetItemTextArray( songList );
 }
 CleanupStack::PopAndDestroy( unknownArtistText );
 }
-iSelectedAlbumHandler->SaveSelectedAlbum(*iSelectedMediaInAlbumView);
+iSelectedAlbumHandler->SaveSelectedAlbumL(*iSelectedMediaInAlbumView);
 }
 }
 // -----------------------------------------------------------------------------
 // CMPXCollectionViewHgContainer::RestoreSelectedAlbumItemL
 {
 CMPXCollectionViewHgContainer* self = static_cast<CMPXCollectionViewHgContainer*>(aPtr);
 if( self )
 {
 //check if the pointer to ContainerMedia exists
 const CMPXMedia& media = self->iListBoxArray->ContainerMedia();
 if ( NULL == &media )
 	    {
 return KErrNone;
 	    }
-self->HandleLbxItemAdditionL();
+MPX_TRAPD( err, self->HandleLbxItemAdditionL() );
+if ( err != KErrNone )
+	{
+MPX_DEBUG2("CMPXCollectionViewHgContainer::AsyncCallback() return err%d", err );
+return err;
+	}
 if( self->iCbaHandler )
 {
 self->iCbaHandler->UpdateCba();
 }
 }
 return KErrNone;
 }
 //
 void CMPXCollectionViewHgContainer::LoadAndSetEmptyTextL()
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::LoadAndSetEmptyTextL" );
 MPX_DEBUG2( "CMPXCollectionViewHgContainer::LoadAndSetEmptyTextL - iContext %d", iContext );
 TInt resId( 0 );
 switch ( iContext )
 {
 case EContextGroupAlbum:
 {
 resId = R_MPX_VMP_NO_ALBUMS;

branch	RCL_3
changeset 21	a1247965635c
parent 18	c54d95799c80
child 26	70a8526f03f2