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

equal deleted inserted replaced

-:13afc0e517bd
+:943ff5625028
 #include <mpxcollectionpath.h>
 #include <mpxplaybackutility.h>
 #include <mpxcollectionviewhg.rsg>
 #include <mpxcollectionviewhg.mbg>
 #include <mpxappui.hrh>
+#include <mpxmusicplayerviewplugin.hrh>
 #include <ganes/HgDoubleGraphicListFlat.h>
 #include <ganes/HgSingleGraphicList.h>
 #include <ganes/HgSingleTextListWithIcon.h>
 #include <ganes/HgVgItem.h>
 #include <ganes/HgItem.h>
 #include <ganes/HgScrollerWithTitle.h>
 #include <ganes/HgVgMediaWall.h>
 #include <layoutmetadata.cdl.h>
+#include <akntranseffect.h>                 // For transition effects
+#include <gfxtranseffect\gfxtranseffect.h>  // For transition effects
 #include "mpxcommoncontainer.hrh"
 #include "mpxcollectionviewhg.hrh"
 #include "mpxcollectionviewhglistboxarray.h"
 #include "mpxcollectionviewhg.hlp.hrh"
 #include "mpxcollectionviewhgcontainer.h"
 #include "mpxcollectionviewhgplaylisthelper.h"
 #include "mpxcollectionviewhgtnloader.h"
 #include "mpxcbahandler.h"
+#include "mpxselectedalbumhandler.h"
+#include "mpxpopuplist.h"
 // CONSTANTS
 _LIT( KMPXCollectionViewRscPath, "mpxcollectionviewhg.rsc" );
 _LIT( KMPXCollectionViewIconFile, "mpxcollectionviewhg.mbm" );
 const TInt KMPXListSelectionCount = 5;
 const TInt KMPXListBufferSizeWithMediaWall = 80;
 #endif
 const TInt KMPXMaxFileLength = 256;
 const TReal KIconFactor = 0.7;
+const TInt KThumbLoadingPauseForTransition(500000);
 _LIT( KMPXDash, " - " );
 #ifdef HG_MP_LOC_AVAILABLE
 _LIT( KMPXSpace, " ");
 #endif //HG_MP_LOC_AVAILABLE
 _LIT( KMPXZeroDurationMark, "--");
 _LIT( KAlbum, " album" );
 _LIT( KAlbums, " albums" );
 _LIT( KSongDash, " song - " );
 _LIT( KSongsDash, " songs - " );
-_LIT( KMPXDriveC, "c:" );
-_LIT( KMPXSelectedAlbumItemFileName, "mpxalbumitem.dat");
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // Two-phased constructor.
 // ---------------------------------------------------------------------------
 //
 CMPXCollectionViewHgContainer* CMPXCollectionViewHgContainer::NewL(
 MEikCommandObserver* aView,
 MEikListBoxObserver* aObserver,
+MMPXSelectedAlbumHandler* aSelectedAlbumHandler,
 TBool aIsEmbedded)
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::NewL" );
 CMPXCollectionViewHgContainer* self =
-new ( ELeave ) CMPXCollectionViewHgContainer(aView, aObserver, aIsEmbedded);
+new ( ELeave ) CMPXCollectionViewHgContainer(
+aView, aObserver, aSelectedAlbumHandler, aIsEmbedded);
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop( self );
 return self;
 }
 // ---------------------------------------------------------------------------
 //
 CMPXCollectionViewHgContainer::CMPXCollectionViewHgContainer(
 MEikCommandObserver* aView,
 MEikListBoxObserver* aObserver,
+MMPXSelectedAlbumHandler* aSelectedAlbumHandler,
 TBool aIsEmbedded) :
 	iView( aView ),
 	iListBoxObserver( aObserver ),
 	iReady( EFalse ),
 	iIsEmbedded(aIsEmbedded),
 	iContext( EContextUnknown ),
 	iTopIndex( 0 ),
 	iBottomIndex( KErrNotFound ),
 	iAlbumIndex(KErrNotFound),
 	iSelectedAlbumIndex(KErrNotFound),
-	iRestoredAlbumIndex(KErrNotFound)
+	iRestoredAlbumIndex(KErrNotFound),
+	iSelectedAlbumHandler (aSelectedAlbumHandler),
+	iOpenAlbumTracks(EFalse),
+	iShuffleItem(0),
+	iSetEmptyTextNeeded(EFalse),
+	iPopupListRect(TRect(0,0,0,0)),
+	iPreviousViewId(TUid::Uid(0))
 {
 }
 // ---------------------------------------------------------------------------
 // Destructor
 iListSelections = new (ELeave) CArrayFixFlat<TInt>( KMPXListSelectionCount );
 iThumbnailManager = CMpxTNLoader::NewL( *this, EAudioListThumbnailSize );
 iImageSize = CHgDoubleGraphicListFlat::PreferredImageSize();
-TFileName pathWithoutDrive;
-iEikonEnv->FsSession().PrivatePath( pathWithoutDrive );
-iSelectedAlbumItemFileName.Copy( KMPXDriveC );
-iSelectedAlbumItemFileName.Append( pathWithoutDrive );
-iSelectedAlbumItemFileName.Append( KMPXSelectedAlbumItemFileName );
 iListBoxArray = static_cast<CMPXCollectionViewListBoxArray*>(
 CreateListBoxArrayL() );
 CreateIconArrayL();
 iCoeEnv->AddForegroundObserverL( *this );
 TCallBack callback(CMPXCollectionViewHgContainer::AsyncCallback, this);
 iAsyncCallBack = new (ELeave) CAsyncCallBack( CActive::EPriorityStandard );
 iAsyncCallBack->Set(callback);
+GfxTransEffect::Enable();
 CreateWindowL();
 ActivateL();
 }
 {
 delete iIconArray;
 iIconArray = NULL;
 CreateIconArrayL();
-if( iCurrentViewType == EMPXViewCoverFlow || iCurrentViewType == EMPXViewTBone )
+if( iCurrentViewType == EMPXViewMediawall || iCurrentViewType == EMPXViewTBone )
 {
 	iMediaWall->SetDefaultIconL(NULL);
 iMediaWall->EnableScrollBufferL(*this, KMPXListBufferSize, KMPXListBufferSize/4);
 }
 else
 }
 			SetDetailIconShuffleL();
 }
 else if ( aType == KEikDynamicLayoutVariantSwitch )
 {
-if ( iCurrentViewType == EMPXViewCoverFlow )
+if ( iCurrentViewType == EMPXViewMediawall )
 {
 if ( iDialog )
 {
 iDialog->CancelPopup();
-iDialog = NULL;
 }
 }
-if( iCurrentViewType == EMPXViewTBone )
+iSetEmptyTextNeeded = ETrue;
+// Coe env is in middle if notifying observers (controls).
+// Just to be safe, lets just create a small async callback and then
+// call HandleLbxItemAdditionL
+if( !iAsyncCallBack->IsActive() )
 {
-				iCollectionUtility->Collection().BackL();
+iAsyncCallBack->CallBack();
 }
-else
-{
+iLayoutSwitch = ETrue;
-// Coe env is in middle if notifying observers (controls).
-// Just to be save, lets just create a small async callback and then
-// call HandleLbxItemAdditionL
-if( !iAsyncCallBack->IsActive() )
-{
-iAsyncCallBack->CallBack();
-}
-}
 if( iCbaHandler )
 iCbaHandler->UpdateCba();
 TRect clientRect = ((CAknView*)iView)->ClientRect();
 SetRect( clientRect );
 iBgContext->SetRect(((CAknAppUi*)iCoeEnv->AppUi())->ApplicationRect());
 }
 );
+if(iMediaWall)
+iMediaWall->HandleResourceChange( aType );
+if(iListWidget)
+iListWidget->HandleResourceChange( aType );
+if(iMwListWidget)
+iMwListWidget->HandleResourceChange( aType );
 }
 // ---------------------------------------------------------------------------
 // From CCoeControl
 //
 TCoeInputCapabilities CMPXCollectionViewHgContainer::InputCapabilities() const
 	{
 	switch( iCurrentViewType )
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 case EMPXViewTBone:
 {
 return iMediaWall->InputCapabilities();
 }
 case EMPXViewList:
 MPX_FUNC( "CMPXCollectionViewHgContainer::CurrentListItemCount" );
 TInt count = 0;
 switch( iCurrentViewType )
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 case EMPXViewTBone:
 {
 count = iMediaWall->ItemCount();
 break;
 }
 if ( count <= 0 )
 return index;
 switch( iCurrentViewType )
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 case EMPXViewTBone:
 {
-index = iMediaWall->SelectedIndex();
+index = MediaIndex(iMediaWall->SelectedIndex());
 break;
 }
 case EMPXViewList:
 {
-index = iListWidget->SelectedIndex();
+index = MediaIndex(iListWidget->SelectedIndex());
 break;
 }
 default:
 break;
 }
 {
 MPX_DEBUG2( "CMPXCollectionViewHgContainer::DrawLbxItem (aIndex=%d)", aIndex );
 CHgScroller* list = CurrentListWidget();
-if( list && aIndex < list->ItemCount() )
+	TInt listIndex = aIndex + iShuffleItem;
-{
+if( list && listIndex < list->ItemCount() )
-CHgItem* item = &list->ItemL(aIndex);
+{
+CHgItem* item = &list->ItemL(listIndex);
 SetDetailIndicatorL(item, aIndex);
-list->RefreshScreen(aIndex);
+list->RefreshScreen(listIndex);
 }
 }
 // -----------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::HandleLbxItemAdditionL()
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::HandleLbxItemAdditionL" );
 SetCollectionContextL();
+	// When the collection is reopened after coming from playback view,
+	// it is reopened in Album-Tracks level (EContextItemAlbum).
+	// We don't display its content in that context but inturn reopen the
+	// collection at one level up (Albums) and display it in T-bone view.
+	// T-Bone view is just a list of albums presented differently.
+if ( iContext == EContextItemAlbum )
+		{
+		iCollectionUtility->Collection().BackL();
+		iOpenAlbumTracks = ETrue;
+		return;
+		}
 iLastValidMediaItemIndex = 0;
 const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
-const TInt count( mediaArray.Count() );
+TInt count( mediaArray.Count() );
 MPX_DEBUG2( "CMPXCollectionViewHgContainer::HandleLbxItemAdditionL count=%d", count);
 HandleLbxItemRemovalL();
-iThumbnailReqMap.Reset();
-iThumbnailReqMap.ReserveL(count);
-for ( TInt i = 0; i < count; i++ )
-{
-iThumbnailReqMap.Append( EFalse );
-}
-iThumbnailManager->CancelAll();
 TViewType prevViewType = iCurrentViewType;
 ResolveCurrentViewType();
+iThumbnailReqMap.Reset();
+if (ShuffleItemPresent())
+iShuffleItem = 1;
+else
+	iShuffleItem = 0;
+count = count + iShuffleItem;
+iThumbnailReqMap.ReserveL(count );
+for ( TInt i = 0; i < count ; i++ )
+{
+iThumbnailReqMap.Append( EFalse );
+}
+iThumbnailManager->CancelAll();
 if( prevViewType == iCurrentViewType && iContext == iPrevContext )
 {
 ResizeListL( mediaArray, count );
 }
 else
 {
 // MediaWall sets the default icon in the construction phase.
 iDefaultIconSet = EFalse;
+if( !iLayoutSwitch  )
+{
+			// We only need to use this for one transition coming
+			// from playback view.
+			TBool pbv = (iPreviousViewId == TUid::Uid(KMPXPluginTypePlaybackUid)) ? ETrue : EFalse;
+			if ( pbv )
+				{
+	iPreviousViewId = TUid::Uid(0);
+				}
+BeginFullScreenAnimation( pbv );
+}
 switch (iCurrentViewType)
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 {
 TMPXPlaybackState pbState( iPlaybackUtility->StateL() );
 if ( pbState == EPbStatePlaying || pbState == EPbStatePaused )
 RestoreSelectedAlbumItemL(mediaArray);
 PrepareMediaWallL(mediaArray, count);
+iOpenAlbumTracks = EFalse;
 break;
 }
 case EMPXViewTBone:
 {
 RestoreSelectedAlbumItemL(mediaArray);
 PrepareMediaWallWithListL( mediaArray, count );
+				// We need to adjust the CBA for this view.
+				if( iCbaHandler )
+					iCbaHandler->UpdateCba();
 break;
 }
 case EMPXViewList:
 {
 PrepareListL(mediaArray, count);
+iOpenAlbumTracks = EFalse;
 break;
 }
 default:
 User::Leave( KErrGeneral );
 break;
 }
 }
 DrawableWindow()->SetOrdinalPosition( -1 );
 CleanPrevView();
 iPrevViewType = iCurrentViewType;
 iPrevContext = iContext;
+if ( iSetEmptyTextNeeded )
+{
+LoadAndSetEmptyTextL();
+iSetEmptyTextNeeded = EFalse;
+}
 if( !iDefaultIconSet )
 {
 SetDefaultIconL();
 }
+iLayoutSwitch = EFalse;
 }
 // -----------------------------------------------------------------------------
 // Handle listbox item addition, preserving the current display index
 // -----------------------------------------------------------------------------
 {
 iMediaWall->ResizeL( aCount );
 ProvideDataWithoutThumbnailsMwL(aMediaArray);
 index = index >= 0 ? index : 0;
 iMediaWall->SetSelectedIndex( index );
-OpenAlbumL( index );
+if ( iCurrentViewType == EMPXViewTBone )
+{
+OpenAlbumL( index );
+}
 }
 else
 {
 iMediaWall->RefreshScreen(0);
 }
 // TODO. Define here in which views we need to have buffering enabled in the list
 if( iContext == EContextGroupAlbum ||
 iContext == EContextGroupArtist ||
 iContext == EContextGroupSong ||
-iContext == EContextItemPlaylist ||
+iContext == EContextItemPlaylist )
-iContext == EContextGroupGenre )
 {
 iListWidget->EnableScrollBufferL(*this, KMPXListBufferSize, KMPXListBufferSize/4);
 }
 else
 {
+EndFullScreenAnimation();
 iListWidget->RefreshScreen(0);
 }
 iDefaultIconSet = EFalse;
 }
 				mediaWallRect,
 				aCount,
 				CHgVgMediaWall::EHgVgMediaWallStyleCoverflowTBonePortrait,
 				EFalse,
 				this,
-				DefaultIconL() );
+				NULL );
 		if( !iIsForeground )
 		    iMediaWall->HandleLosingForeground();
 		iMediaWall->SetMopParent(this);
 iMwListWidget->SetRect( mwListRect );
 iMwListWidget->DrawNow();
 }
 	    }
+if( iTranstionType != EMPXTranstionNotDefined )
+{
+iMediaWall->SetFlags( CHgVgMediaWall::EHgVgMediaWallDrawToWindowGC );
+}
+iMediaWall->SetOpeningAnimationType( CHgVgMediaWall::EHgVgOpeningAnimationNone );
 if ( iAlbumIndex == KErrNotFound )
 {
 iMediaWall->SetSelectedIndex( iRestoredAlbumIndex );
-iMediaWall->RefreshScreen(iRestoredAlbumIndex);
+// If we are about to start a transition animation we should draw only
+// when we have received first screen of thumbs in Refresh function.
+if( iTranstionType == EMPXTranstionNotDefined )
+iMediaWall->RefreshScreen(iRestoredAlbumIndex);
 OpenAlbumL(iRestoredAlbumIndex);
 }
 else
 {
 iMediaWall->SetSelectedIndex( iAlbumIndex );
-iMediaWall->RefreshScreen(iAlbumIndex);
+// If we are about to start a transition animation we should draw only
+// when we have received first screen of thumbs in Refresh function.
+if( iTranstionType == EMPXTranstionNotDefined )
+iMediaWall->RefreshScreen(iAlbumIndex);
 OpenAlbumL(iAlbumIndex);
 }
 iMwListWidget->RefreshScreen(0);
-iDefaultIconSet = ETrue;
 }
 // ----------------------------------------------------------------------------
 // Prepare view for displaying data in Media wall format.
 // ----------------------------------------------------------------------------
 iMediaWall->HandleLosingForeground();
 iMediaWall->SetMopParent(this);
 iMediaWall->SetSelectionObserver(*this);
 iMediaWall->SetObserver( this ); // softkey visibility event observer
-iMediaWall->SetOpeningAnimationType( CHgVgMediaWall::EHgVgOpeningAnimationFlipToFront );
 iMediaWall->EnableScrollBufferL(
 *this,
 KMPXListBufferSizeWithMediaWall,
 KMPXListBufferSizeWithMediaWall / 4);
 // We want softkeys to be drawn on top of mediawall, thats we need to manipulate window pos
 iMediaWall->DrawableWindow()->SetOrdinalPosition( -1 );
 ProvideDataWithoutThumbnailsMwL(aMediaArray);
 if( iAlbumIndex == KErrNotFound )
-iMediaWall->SetSelectedIndex( iRestoredAlbumIndex );
+iMediaWall->SetSelectedIndex( iRestoredAlbumIndex + iShuffleItem );
 else
-iMediaWall->SetSelectedIndex( iAlbumIndex );
+iMediaWall->SetSelectedIndex( iAlbumIndex + iShuffleItem );
 	    }
 	else
 	    {
-	    // TODO, do we need to refill the data or are the items same in fullscreen coverflow and tbone coverflow????
-	    // David: Yes because there will be an extra shuffle item in the coverflow list but not in tbone coverflow.
-	    //        Index will be off.
 	    if( iMediaWall->Style() != CHgVgMediaWall::EHgVgMediaWallStyleCoverflowFullScreen )
 	        iMediaWall->ChangeStyleL( CHgVgMediaWall::EHgVgMediaWallStyleCoverflowFullScreen, appRect, ETrue );
 	    iMediaWall->MakeVisible( ETrue );
 iMediaWall->SetFocus( ETrue );
 iMediaWall->EnableScrollBufferL(
 *this,
 KMPXListBufferSizeWithMediaWall,
 KMPXListBufferSizeWithMediaWall / 4);
 if( iAlbumIndex == KErrNotFound )
-iMediaWall->SetSelectedIndex( iRestoredAlbumIndex );
+iMediaWall->SetSelectedIndex( iRestoredAlbumIndex + iShuffleItem );
 else
-iMediaWall->SetSelectedIndex( iAlbumIndex );
+iMediaWall->SetSelectedIndex( iAlbumIndex + iShuffleItem );
-iMediaWall->DrawDeferred();
 	    }
+if( iTranstionType != EMPXTranstionNotDefined )
+{
+iMediaWall->SetFlags( CHgVgMediaWall::EHgVgMediaWallDrawToWindowGC );
+}
+	if( iPopupListRect == TRect(0,0,0,0) )
+		{
+	    ResolvePopupListSizeL();
+		}
+iMediaWall->SetOpenedItemRect( iPopupListRect );
+iMediaWall->SetOpeningAnimationType( CHgVgMediaWall::EHgVgOpeningAnimationZoomToFront );
 	iDefaultIconSet = ETrue;
 }
 // ----------------------------------------------------------------------------
 switch (iContext)
 {
 case EContextGroupAlbum:
 {
 if( landscapeOrientation )
-iCurrentViewType = EMPXViewCoverFlow;
+iCurrentViewType = EMPXViewMediawall;
 else
-iCurrentViewType = EMPXViewList;
+	{
+				// In case we want to display the albums in T-Bone view
+				// we change the view type and context appropriately.
+				if ( iOpenAlbumTracks )
+					{
+	iCurrentViewType = EMPXViewTBone;
+	iContext = EContextItemAlbum;
+	iOpenAlbumTracks = EFalse;
+					}
+				else
+					{
+					iCurrentViewType = EMPXViewList;
+					}
+				}
 break;
 }
 case EContextItemAlbum:
 case EContextItemArtist:
 {
-// TODO, Change by Harri. Is this correct?
 if( landscapeOrientation )
-iCurrentViewType = EMPXViewCoverFlow;
+iCurrentViewType = EMPXViewMediawall;
 else
 iCurrentViewType = EMPXViewTBone;
 break;
 }
 default:
 if( iCurrentViewType == iPrevViewType )
 return;
 switch (iPrevViewType)
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 {
 if( iCurrentViewType != EMPXViewTBone )
 {
 delete iMediaWall;
 iMediaWall = 0;
 }
 break;
 }
 case EMPXViewTBone:
 {
-if( iCurrentViewType != EMPXViewCoverFlow )
+if( iCurrentViewType != EMPXViewMediawall )
 {
 delete iMediaWall;
 iMediaWall = 0;
 }
 delete iMwListWidget;
 TBool CMPXCollectionViewHgContainer::IsSelectedItemASong()
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::IsSelectedItemASong" );
 	TBool res(EFalse);
-if ( iContext == EContextItemAlbum || iContext == EContextGroupSong )
+if ( iContext == EContextItemAlbum ||
+iContext == EContextGroupSong ||
+iContext == EContextItemGenre )
 {
 	CHgScroller* listWidget = CurrentListWidget();
+	if ( !listWidget )
+			{
+			return EFalse;
+			}
 		if ( listWidget->SelectedIndex() == 0 &&
 			 listWidget->ItemCount() > 1 )
 			{
 			res = EFalse;
 			}
 CMPXMedia* album( albums.AtL( iSelectedAlbumIndex ) );
 const CMPXMediaArray* songs = album->Value<CMPXMediaArray>(KMPXMediaArrayContents);
 CHgScroller* listWidget = CurrentListWidget();
 if (listWidget && songs)
 {
+		// Tracks list may have a shuffle item inserted so account for that.
 if (listWidget->ItemCount() > 1)
 {
 song = songs->AtL(listWidget->SelectedIndex()-1);
 }
 else
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::HandleItemCommanddL" );
 if( aCommand == EMPXCmdPlay )
 {
-switch( iCurrentViewType )
+if ( iContext == EContextGroupAlbum  )
 {
-case EMPXViewCoverFlow:
+iSelectedAlbumIndex = MediaIndex(iListWidget->SelectedIndex());
-case EMPXViewTBone:
+SaveSelectedAlbumItemL(iSelectedAlbumIndex);
-{
+// Open first song of album & playlist for entire album is created.
-iSelectedAlbumIndex = iMediaWall->SelectedIndex();
+PlayAlbumL(iSelectedAlbumIndex);
-SaveSelectedAlbumItemL(iSelectedAlbumIndex);
+}
-// Open first song of album & playlist for entire album is created.
+else if ( iContext == EContextGroupPlaylist  )
-UpdatePathAndOpenL(0, ETrue);
+{
-break;
+TInt index = MediaIndex(iListWidget->SelectedIndex());
-}
+PlayPlaylistL(index);
-case EMPXViewList:
+}
-{
+else if ( iContext == EContextGroupGenre  )
-if ( iContext == EContextGroupAlbum  )
+{
-{
+TInt index = MediaIndex(iListWidget->SelectedIndex());
-iSelectedAlbumIndex = iListWidget->SelectedIndex();
+PlayGenreL(index);
-SaveSelectedAlbumItemL(iSelectedAlbumIndex);
-// Open first song of album & playlist for entire album is created.
-PlayAlbumL(iSelectedAlbumIndex);
-}
-else if ( iContext == EContextGroupPlaylist  )
-{
-TInt index = iListWidget->SelectedIndex();
-PlayPlaylistL(index);
-}
-else if ( iContext == EContextGroupGenre  )
-{
-TInt index = iListWidget->SelectedIndex();
-PlayGenreL(index);
-}
-break;
-}
-default:
-break;
 }
 }
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::HandleSelectL( TInt aIndex, CCoeControl* aControl )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::HandleSelect" );
-if( iCurrentViewType == EMPXViewTBone && iSelectedAlbumIndex != aIndex )
+TInt index(MediaIndex(aIndex));
+if( iCurrentViewType == EMPXViewTBone && iSelectedAlbumIndex != index )
 {
 if ( aControl == iMediaWall )
 {
-iSelectedAlbumIndex = aIndex;
+iSelectedAlbumIndex = index;
-OpenAlbumL(aIndex);
+OpenAlbumL(index);
 }
 }
-else if( iCurrentViewType == EMPXViewCoverFlow )
+else if( iCurrentViewType == EMPXViewMediawall )
 {
-iSelectedAlbumIndex = aIndex;
+iSelectedAlbumIndex = index;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::HandleOpenL( TInt aIndex )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::HandleOpenL" );
-// Mod by harri, had to enable this block since ganes list components still
+TInt index(MediaIndex(aIndex));
-// uses this version of the HandleOpen
+// ganes list components still uses this version of the HandleOpen
 if ( iContext == EContextItemAlbum  )
 		{
 SaveSelectedAlbumItemL(iSelectedAlbumIndex);
-		UpdatePathAndOpenL(aIndex);
+		UpdatePathAndOpenL(index);
 		}
 else if ( iContext == EContextGroupAlbum )
 {
-SaveSelectedAlbumItemL(aIndex);
+SaveSelectedAlbumItemL(index);
+iAlbumIndex = index;
 // Check if shuffle play all was selected.
-if (!ShufflePlayAllL(aIndex))
+if (!ShufflePlayAllL(index))
 {
 			// To open the selected album.
-iView->ProcessCommandL( EMPXCmdCommonEnterKey );
+PrepareTboneViewL();
 }
 }
-else if ( iContext == EContextGroupSong || iContext == EContextItemPlaylist )
+else if ( iContext == EContextGroupSong || iContext == EContextItemPlaylist || iContext == EContextItemGenre )
 {
 // Check if shuffle play all was selected.
-if (!ShufflePlayAllL(aIndex))
+if (!ShufflePlayAllL(index))
 {
 // To open the selected album.
 iView->ProcessCommandL( EMPXCmdCommonEnterKey );
 }
 }
 //
 void CMPXCollectionViewHgContainer::HandleOpenL( TInt aIndex, CCoeControl* aControl )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::HandleOpenL" );
-if( iContext == EContextGroupAlbum )
+TInt index(MediaIndex(aIndex));
-{
-iAlbumIndex = aIndex;
+if( iContext == EContextGroupAlbum && index >= 0 )
-iSelectedAlbumIndex = aIndex;
+{
-SaveSelectedAlbumItemL(aIndex);
+iAlbumIndex = index;
+iSelectedAlbumIndex = index;
+SaveSelectedAlbumItemL(index);
 }
 if ( iContext == EContextItemAlbum  )
 {
+if( iCurrentViewType == EMPXViewTBone )
+{
+iMediaWall->SetFlags( CHgVgMediaWall::EHgVgMediaWallDrawToWindowGC );
+iMediaWall->DrawNow();
+}
 if ( aControl == iMediaWall )
 {
 			// If album was opened, we will play all tracks in the album.
-SaveSelectedAlbumItemL(aIndex);
+SaveSelectedAlbumItemL(index);
 // Open first song of album & playlist for entire album is created.
 UpdatePathAndOpenL(0, ETrue);
 }
 else if ( aControl == iMwListWidget )
 {
 			// If item in list was opened, we only play the selected one.
 SaveSelectedAlbumItemL(iSelectedAlbumIndex);
 // Open the selected song of album
-UpdatePathAndOpenL(aIndex);
+UpdatePathAndOpenL(index);
 }
 }
 else if ( iContext == EContextGroupAlbum  )
 {
 if ( aControl == iMediaWall )
 {
 			// Check if shuffle play all was selected.
-			if (!ShufflePlayAllL(aIndex))
+			if (!ShufflePlayAllL(index))
 				{
-	            OpenAlbumL(aIndex);
+	            OpenAlbumL(index);
 				}
 }
 }
 else
 {
 	// This should not happen but if not handled, bad things will happen.
 	if ( aBufferStart < 0 || aBufferEnd < 0 )
 	    return;
-	// TODO, add support for last valid media item index later
+if ( aBufferStart - iShuffleItem > iLastValidMediaItemIndex ||
-if ( aBufferStart > iLastValidMediaItemIndex || aBufferEnd > iLastValidMediaItemIndex )
+aBufferEnd - iShuffleItem > iLastValidMediaItemIndex )
 		{
 		// We cannot provide data for the requested range at this time.
 		// Remember the request so we can handle it when there's enough data.
 		iRequestStart = aBufferStart;
 	iRequestEnd = aBufferEnd;
 else
 {
 firstOnScreen = iListWidget->FirstIndexOnScreen();
 lastOnScreen = firstOnScreen + iListWidget->ItemsOnScreen();
 }
-const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
 TInt startIndex = Max( firstOnScreen, aBufferStart );
 TInt endIndex = Min( lastOnScreen, aBufferEnd );
 ProvideDataForRangeL( startIndex, endIndex );
 // -----------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::ProvideDataForRangeL( TInt aBufferStart, TInt aBufferEnd )
 {
 const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
+TInt index(0);
 for( TInt i = aBufferStart; i <= aBufferEnd; i++ )
 {
 // Just get the exiting item and update the fields + icon.
 CHgItem* item = NULL;
 if( iMediaWall )
 item = &iMediaWall->ItemL(i);
 else
 item = &iListWidget->ItemL(i);
-CMPXMedia* currentMedia( mediaArray.AtL( i ) );
+index = MediaIndex(i);
-AddThumbnailToDisplayedItemL( item, currentMedia, i );
+if ( index >= 0 )
+{
+CMPXMedia* currentMedia( mediaArray.AtL( index ) );
+AddThumbnailToDisplayedItemL( item, currentMedia, index );
+}
+else
+	{
+			if ( iCurrentViewType == EMPXViewMediawall ||
+				 iCurrentViewType == EMPXViewList && (i-iShuffleItem) == -1 )
+				SetDetailIconShuffleL();
+			iThumbnailReqMap[i] = ETrue;
+			RefreshNoThumbnailL(i);
+			}
 }
 }
 // -----------------------------------------------------------------------------
 // CMPXCollectionViewHgContainer::ProvideDataWithouThumbnailsL
 	const CMPXMediaArray& aMediaArray,
 	TInt aStartIndex )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::ProvideDataWithoutThumbnailsL" );
+	if ( ShuffleItemPresent() )
+		{
+		CHgItem* item = &iListWidget->ItemL(0);
+		SetShuffleItemTextL(item, NULL);
+		}
 	TInt mediaCount = aMediaArray.Count();
 for ( TInt i = aStartIndex; i < mediaCount ; i++ )
 {
 CMPXMedia* currentMedia( aMediaArray.AtL( i ) );
 		if ( currentMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) ==
 			KMPXInvalidItemId )
 			{
 			break;
 			}
 // Just get the exiting item and update the fields + icon.
-CHgItem* item = &iListWidget->ItemL(i);
+CHgItem* item = &iListWidget->ItemL(i+iShuffleItem);
+		SetTitleL( item, currentMedia );
-		TBool shuffleItem(EFalse);
+		AddDetailToDisplayedItemL( item, currentMedia, i );
-if ( i == 0 )
-	{
-shuffleItem = SetShuffleItemTextL(item, currentMedia);
-			}
-if (!shuffleItem)
-	{
-SetTitleL( item, currentMedia );
-	AddDetailToDisplayedItemL( item, currentMedia, i );
-			}
 		iLastValidMediaItemIndex = i;
 }
 }
 // -----------------------------------------------------------------------------
 	const CMPXMediaArray& aMediaArray,
 	TInt aStartIndex )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::ProvideDataWithoutThumbnailsMwL" );
+	if ( ShuffleItemPresent() )
+		{
+		CHgVgItem* item = &iMediaWall->ItemL(0);
+		SetShuffleItemTextL(item, NULL);
+		}
 	TInt mediaCount = aMediaArray.Count();
 for ( TInt i = aStartIndex; i < mediaCount ; i++ )
 {
-// Just get the exiting item and update the fields + icon.
 CMPXMedia* currentMedia( aMediaArray.AtL( i ) );
 		if ( currentMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) ==
 			KMPXInvalidItemId )
 			{
 			break;
 			}
 // Just get the exiting item and update the fields + icon.
+CHgVgItem* item = &iMediaWall->ItemL(i+iShuffleItem);
-CHgVgItem* item = &iMediaWall->ItemL(i);
-		TBool shuffleItem(EFalse);
+		SetTitleL( item, currentMedia );
-if ( i == 0 )
+		AddDetailToDisplayedItemL( item, currentMedia, i );
-	{
-shuffleItem = SetShuffleItemTextL(item, currentMedia);
-			}
-if (!shuffleItem)
-	{
-SetTitleL( item, currentMedia );
-	AddDetailToDisplayedItemL( item, currentMedia, i );
-			}
 		iLastValidMediaItemIndex = i;
 }
 }
 // -----------------------------------------------------------------------------
 // CMPXCollectionViewHgContainer::ProvideDataL
 	MPX_DEBUG3( "CMPXCollectionViewHgContainer::ProvideDataL aStart = %d, aEnd = %d",
 aStart, aEnd );
 	if ( aStart < 0 ) aStart = 0;
 	if ( aEnd < 0 ) aEnd = 0;
+	TInt index(0);
 	const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
 for ( TInt i = aStart; i <= aEnd ; i++ )
 {
 // Just get the exiting item and update the fields + icon.
 CHgItem* item = NULL;
-if( iCurrentViewType == EMPXViewCoverFlow || iCurrentViewType == EMPXViewTBone )
+if( iCurrentViewType == EMPXViewMediawall || iCurrentViewType == EMPXViewTBone )
 item = &iMediaWall->ItemL(i);
 else
 item = &iListWidget->ItemL(i);
-CMPXMedia* currentMedia( mediaArray.AtL( i ) );
+index = MediaIndex(i);
+if ( index >= 0 )
-AddThumbnailToDisplayedItemL( item, currentMedia, i );
+{
-}
+CMPXMedia* currentMedia( mediaArray.AtL( index ) );
-}
+AddThumbnailToDisplayedItemL( item, currentMedia, index );
+}
+}
+}
 // -----------------------------------------------------------------------------
 // CMPXCollectionViewHgContainer::Release
 // -----------------------------------------------------------------------------
 //
 void CMPXCollectionViewHgContainer::Release(TInt aReleaseStart, TInt aReleaseEnd)
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::Release" );
-for(; aReleaseStart <= aReleaseEnd; ++aReleaseStart)
+	TInt temp = aReleaseStart - iShuffleItem;
-{
+	TInt start =  temp >=0 ? temp : 0 ;
-MPX_DEBUG2( "-->CMPXCollectionViewHgContainer::Release aReleaseStart = %d", aReleaseStart );
+	TInt end = aReleaseEnd - iShuffleItem;
-iThumbnailManager->CancelThumb( aReleaseStart );
-}
+for(; start <= end; ++start)
+{
+MPX_DEBUG2( "-->CMPXCollectionViewHgContainer::Release aReleaseStart = %d", start );
+iThumbnailManager->CancelThumb( start );
+}
 }
 // ---------------------------------------------------------------------------
 // Refresh for item without thumbnail
 // ---------------------------------------------------------------------------
 //
-void CMPXCollectionViewHgContainer::RefreshNoThumbnailL(TInt aIndex)
+void CMPXCollectionViewHgContainer::RefreshNoThumbnailL(TInt aDisplayIndex)
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::RefreshNoThumbnail" );
-RefreshL(aIndex);
+RefreshL(aDisplayIndex);
 }
 // ---------------------------------------------------------------------------
 // Refresh list as needed.
 // This function tries to determine the best time to refresh the screen as to
 // avoid too many redraws. In some cases, multiple refresh is unavoidable.
 // ---------------------------------------------------------------------------
 //
-void CMPXCollectionViewHgContainer::RefreshL(TInt aIndex)
+void CMPXCollectionViewHgContainer::RefreshL(TInt aDisplayIndex)
 {
 if( !iIsForeground )
 {
 return;
 }
 MPX_FUNC( "CMPXCollectionViewHgContainer::Refresh" );
 	TInt mediaCount = iListBoxArray->MediaArray().Count();
+	TInt displayCount = mediaCount + iShuffleItem;
 	TInt firstOnScreen = 0;
 	TInt lastOnScreen =  0;
 TBool landscapeOrientation = Layout_Meta_Data::IsLandscapeOrientation();
 CHgScroller* listWidget = CurrentListWidget();
-if( iCurrentViewType == EMPXViewTBone || iCurrentViewType == EMPXViewCoverFlow )
+if( iCurrentViewType == EMPXViewTBone || iCurrentViewType == EMPXViewMediawall )
 {
 firstOnScreen = iMediaWall->FirstIndexOnScreen();
 lastOnScreen = firstOnScreen + iMediaWall->ItemsOnScreen();
 }
 else
 {
 firstOnScreen = listWidget->FirstIndexOnScreen();
 lastOnScreen = firstOnScreen + listWidget->ItemsOnScreen();
 }
-	// Added by Harri
 	if( firstOnScreen < 0 )
 	    firstOnScreen = 0;
-	if (lastOnScreen > (mediaCount - 1))
+	if (lastOnScreen > (displayCount - 1))
-		lastOnScreen = mediaCount - 1;
+		lastOnScreen = displayCount - 1;
 	// Refresh screen if the item is within view and no more thumbnails expected.
-	if ( aIndex >= firstOnScreen && aIndex <= lastOnScreen )
+	if ( aDisplayIndex >= firstOnScreen && aDisplayIndex <= lastOnScreen )
 		{
 		TBool canRefresh(ETrue);
 		for (TInt i= firstOnScreen; i <= lastOnScreen; i++)
 			{
 			if ( !iThumbnailReqMap[i] )
 				break;
 				}
 			}
 if ( canRefresh )
 {
-if( iCurrentViewType == EMPXViewTBone || iCurrentViewType == EMPXViewCoverFlow )
+if( iCurrentViewType == EMPXViewTBone || iCurrentViewType == EMPXViewMediawall )
-iMediaWall->RefreshScreen( firstOnScreen );
+{
+if( iTranstionType != EMPXTranstionNotDefined )
+{
+// This will tricker the transtition animation
+EndFullScreenAnimation();
+iMediaWall->DrawNow();
+}
+else
+{
+iMediaWall->RefreshScreen( firstOnScreen );
+}
+}
 else
-listWidget->RefreshScreen( firstOnScreen );
+{
+if( iTranstionType != EMPXTranstionNotDefined )
+{
+// This will tricker the transtition animation
+// Use DrawNow since RefreshScreen uses DrawDeferred and we want to start
+// the animation immediately.
+EndFullScreenAnimation();
+listWidget->DrawNow();
+}
+else
+{
+listWidget->RefreshScreen( firstOnScreen );
+}
+}
 }
 		}
 }
 // ----------------------------------------------------------------------------
 break;
 }
 case EContextGroupAlbum:
 case EContextItemAlbum:
 {
-// Mod by Harri. Lampainen wanted to try default icon in album view.
 iconIndex = EMPXClvIconAlbum;
 break;
 }
 case EContextGroupPodcast:
 case EContextItemPodcast:
 			break;
 			}
 		case EContextGroupAlbum:
 		case EContextItemAlbum:
 {
-			// Mod by Harri. Lampainen wanted to try default icon in album view.
 defaultIcon = EMPXDefaultIconAlbum;
 iconIndex = EMPXClvIconAlbum;
 			break;
 			}
 		case EContextGroupPodcast:
 			}
 		else
 			{
 			//no albumart
 			// Default album art has already been set earlier.
-		iThumbnailReqMap[aIndex] = ETrue;
+		iThumbnailReqMap[aIndex+iShuffleItem] = ETrue;
 		RefreshNoThumbnailL(aIndex);
 			}
 		}
 	else
 	    {
 		// no album art supported
 		// Default album art has already been set earlier.
-	    if ( iCurrentViewType == EMPXViewCoverFlow ||
+	    if ( iCurrentViewType == EMPXViewMediawall ||
-	         iCurrentViewType == EMPXViewList && aIndex == 0 )
+	         iCurrentViewType == EMPXViewList && (aIndex-iShuffleItem) == -1 )
 	        SetDetailIconShuffleL(); // BUG: temporarily called here because default icon is shown if SetDefaultIconL is called after.
-	iThumbnailReqMap[aIndex] = ETrue;
+	iThumbnailReqMap[aIndex+iShuffleItem] = ETrue;
 RefreshNoThumbnailL(aIndex);
 	    }
 }
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 void CMPXCollectionViewHgContainer::SetDetailIconShuffleL()
 {
-	const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
+	if (iShuffleItem)
-	if (mediaArray.Count())
 		{
-		CMPXMedia* currentMedia( mediaArray.AtL( 0 ) );
+		CGulIcon* icon = (*iIconArray)[EMPXClvIconShuffle];
+		CFbsBitmap* bitmap = icon->Bitmap();
-		TMPXGeneralType type( EMPXNoType );
+		CFbsBitmap* mask = icon->Mask();
-		if ( currentMedia->IsSupported( KMPXMediaGeneralType ) )
-			{
+		TSize size(240,240);
-			type = currentMedia->ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+		CHgItem* item = NULL;
-			}
+		if( iCurrentViewType == EMPXViewMediawall || iCurrentViewType == EMPXViewTBone )
+			{
-		TMPXGeneralCategory category( EMPXNoCategory );
+			item = &iMediaWall->ItemL(0);
-		if ( currentMedia->IsSupported( KMPXMediaGeneralCategory ) )
+			}
-			{
+		else if( iCurrentViewType == EMPXViewList )
-			category = currentMedia->ValueTObjectL<TMPXGeneralCategory>( KMPXMediaGeneralCategory );
+			{
-			}
+			item = &iListWidget->ItemL(0);
+			size = CHgDoubleGraphicListFlat::PreferredImageSize();
-		if ( type == EMPXItem && category == EMPXCommand )
+			}
-			{
+		else
+			{
-			CGulIcon* icon = (*iIconArray)[EMPXClvIconShuffle];
+			User::Leave( KErrNotSupported );
-			CFbsBitmap* bitmap = icon->Bitmap();
+			}
-			CFbsBitmap* mask = icon->Mask();
+		if ( item )
-			TSize size(240,240);
+			{
-			CHgItem* item = NULL;
+			AknIconUtils::SetSize( bitmap, size );
-			if( iCurrentViewType == EMPXViewCoverFlow || iCurrentViewType == EMPXViewTBone )
+			AknIconUtils::SetSize( mask, size );
-				{
-				item = &iMediaWall->ItemL(0);
+			CGulIcon* iconCopy = CGulIcon::NewL(bitmap, mask);
-				}
+			iconCopy->SetBitmapsOwnedExternally(ETrue);
-			else if( iCurrentViewType == EMPXViewList )
+			item->SetIcon( iconCopy );
-				{
-				item = &iListWidget->ItemL(0);
-				size = CHgDoubleGraphicListFlat::PreferredImageSize();
-				}
-			else
-				{
-				User::Leave( KErrNotSupported );
-				}
-			if ( item )
-				{
-				AknIconUtils::SetSize( bitmap, size );
-				AknIconUtils::SetSize( mask, size );
-				CGulIcon* iconCopy = CGulIcon::NewL(bitmap, mask);
-				iconCopy->SetBitmapsOwnedExternally(ETrue);
-				item->SetIcon( iconCopy );
-				}
 			}
 		}
 }
 // ----------------------------------------------------------------------------
 // Set the shuffle item text
 // ----------------------------------------------------------------------------
 TBool CMPXCollectionViewHgContainer::SetShuffleItemTextL(CHgItem* aItem, CMPXMedia* aMedia)
 {
 	TBool res(EFalse);
-TMPXGeneralType type( EMPXNoType );
-if ( aMedia->IsSupported( KMPXMediaGeneralType ) )
+const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
-{
+const TInt count( mediaArray.Count() );
-type = aMedia->ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
-}
+	if ( count > 1 && iContext == EContextGroupAlbum ||
+		 iContext == EContextGroupSong ||
-TMPXGeneralCategory category( EMPXNoCategory );
+		 iContext == EContextGroupGenre ||
-if ( aMedia->IsSupported( KMPXMediaGeneralCategory ) )
+		 iContext == EContextItemPlaylist ||
-{
+		 iContext == EContextItemGenre ||
-category = aMedia->ValueTObjectL<TMPXGeneralCategory>( KMPXMediaGeneralCategory );
+		 iContext == EContextItemSong )
-}
+		{
+		aItem->SetTitleL( _L("Shuffle All") );
-if ( type == EMPXItem && category == EMPXCommand )
-{
-if ( aMedia->IsSupported( KMPXMediaGeneralTitle ) )
-{
-const TDesC& title = aMedia->ValueText( KMPXMediaGeneralTitle );
-if ( title.Compare( KNullDesC ) != 0 )
-{
-aItem->SetTitleL( title );
-}
-else
-{
-HBufC* unknownText =
-StringLoader::LoadLC( R_MPX_COLLECTION_UNKNOWN );
-aItem->SetTitleL( *unknownText );
-CleanupStack::PopAndDestroy( unknownText );
-}
-}
-if ( aMedia->IsSupported( KMPXMediaColDetailNumberOfItems ) )
-{
-TInt songsCount = aMedia->ValueTObjectL<TInt>( KMPXMediaColDetailNumberOfItems );
-			HBufC* songsTitle = StringLoader::LoadLC( R_MPX_COLLECTION_DETAILS_NUMBER_OF_SONGS, songsCount );
-			TPtr ptr = songsTitle->Des();
-			AknTextUtils::LanguageSpecificNumberConversion( ptr );
-			aItem->SetTextL( ptr );
-			CleanupStack::PopAndDestroy( songsTitle );
-}
 		// We can try to set icon too.
 		SetDetailIconShuffleL();
 		res = ETrue;
 		}
 void CMPXCollectionViewHgContainer::TNReadyL(TInt aError, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/, TInt aIndex)
 {
-if ( aError == KErrNone )
+TInt displayIndex = aIndex+iShuffleItem;
+if ( aError == KErrNone )
 {
 const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
 CMPXMedia* currentMedia( mediaArray.AtL( aIndex ) );
 if ( currentMedia->IsSupported( KMPXMediaGeneralId ) )
 {
 {
 CGulIcon* icon = CGulIcon::NewL(aBitmap, NULL);
 switch (iCurrentViewType)
 {
-case EMPXViewCoverFlow:
+case EMPXViewMediawall:
 case EMPXViewTBone:
 {
-iMediaWall->ItemL(aIndex).SetIcon(icon);
+iMediaWall->ItemL(displayIndex).SetIcon(icon);
-					iThumbnailReqMap[aIndex] = ETrue;
 break;
 }
 case EMPXViewList:
 {
-iListWidget->ItemL(aIndex).SetIcon(icon);
+iListWidget->ItemL(displayIndex).SetIcon(icon);
-					iThumbnailReqMap[aIndex] = ETrue;
 break;
 }
 default:
 break;
 }
-RefreshL(aIndex);
 }
 }
 }
 else
 {
 //no albumart supported
-iThumbnailReqMap[aIndex] = ETrue;
+//iThumbnailReqMap[displayIndex] = ETrue;
-RefreshL(aIndex);
+//RefreshL(displayIndex);
 }
+	iThumbnailReqMap[displayIndex] = ETrue;
+	RefreshL(displayIndex);
 }
 // ----------------------------------------------------------------------------
 // Clears the TN request if any
 // ----------------------------------------------------------------------------
 				{
 				if ( pbState == EPbStatePaused )
 					{
 					iPlaybackUtility->CommandL( EPbCmdPlay );
 					}
-iPlaybackUtility->SetL( EPbPropertyRandomMode, shuffle );
+iPlaybackUtility->SetL( EPbPropertyRandomMode, EFalse );
 				iView->ProcessCommandL( EMPXCmdGoToNowPlaying );
 				}
 			else
 			    {
-iPlaylistHelper->InitPlaylistL(*cpath, shuffle);
+	iPlaybackUtility->SetL( EPbPropertyRandomMode, shuffle );
+iCollectionUtility->Collection().OpenL(*cpath);
 			    }
 			}
 		else
 		    {
-iPlaylistHelper->InitPlaylistL(*cpath, shuffle);
+iPlaybackUtility->SetL( EPbPropertyRandomMode, shuffle );
+iCollectionUtility->Collection().OpenL(*cpath);
 		    }
 		CleanupStack::PopAndDestroy( cpath );
-		// We need to restore the status pane before switching to playback view.
-		if (!((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->IsVisible())
-			((CAknAppUi*)iCoeEnv->AppUi())->StatusPane()->MakeVisible(ETrue);
 		}
 	CleanupStack::PopAndDestroy(&ids);
 	}
 	TInt selectedIndex(0);
 CHgScroller* listWidget = CurrentListWidget();
 	if ( iContext == EContextGroupPlaylist ||
 	     iContext == EContextGroupGenre && listWidget )
 		{
-		selectedIndex = listWidget->SelectedIndex();
+		selectedIndex = MediaIndex(listWidget->SelectedIndex());
 		}
 	else
 		{
 		return;
 		}
 CMPXMedia* album( mediaArray.AtL( aIndex ) );
 if( album->IsSupported(KMPXMediaArrayContents) )
 {
 // We've previously fetched the songs for this album so
 // all we do now is populate the list with the song titles.
-if( iCurrentViewType == EMPXViewCoverFlow )
+if( iCurrentViewType == EMPXViewMediawall )
 {
 ShowAlbumSongsDialogL(*album);
 }
 else
 {
 TBool CMPXCollectionViewHgContainer::ShufflePlayAllL(TInt aIndex)
 {
 MPX_FUNC("CMPXCollectionViewHgContainer::ShufflePlayAllL");
 TBool shuffle(EFalse);
-const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
+if ( aIndex == -1 )
-	CMPXMedia* currentMedia( mediaArray.AtL( aIndex ) );
+{
+shuffle = ETrue;
-TMPXGeneralType type( EMPXNoType );
+if ( iContext == EContextItemPlaylist || iContext == EContextItemGenre )
-if ( currentMedia->IsSupported( KMPXMediaGeneralType ) )
+{
-{
+CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
-type = currentMedia->ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+CleanupStack::PushL( cpath );
-}
+iPlaylistHelper->InitPlaylistL(*cpath, shuffle);
+CleanupStack::PopAndDestroy( cpath );
-TMPXGeneralCategory category( EMPXNoCategory );
+}
-if ( currentMedia->IsSupported( KMPXMediaGeneralCategory ) )
+else
 {
-category = currentMedia->ValueTObjectL<TMPXGeneralCategory>( KMPXMediaGeneralCategory );
+iPlaylistHelper->InitPlaylistL(shuffle);
 }
-if ( type == EMPXItem && category == EMPXCommand )
-{
-		shuffle = ETrue;
-		if ( iContext == EContextItemPlaylist )
-			{
-			CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();
-			CleanupStack::PushL( cpath );
-			cpath->Remove(0); // we want to remove index 0 which is shuffle item
-			iPlaylistHelper->InitPlaylistL(*cpath, shuffle);
-			CleanupStack::PopAndDestroy( cpath );
-			}
-		else
-			{
-			iPlaylistHelper->InitPlaylistL(shuffle);
-			}
 }
 return shuffle;
 }
 				albumMedia->SetTObjectValueL<TInt>(KMPXMediaArrayCount, songArray->Count());
 				}
 			if ( iFindOp == EMPXOpenAlbum )
 			    {
-if( iCurrentViewType == EMPXViewCoverFlow )
+if( iCurrentViewType == EMPXViewMediawall )
 {
 ShowAlbumSongsDialogL( aResults );
 }
 else
 {
 void CMPXCollectionViewHgContainer::ShowAlbumSongsDialogL( const CMPXMedia& aResults )
 {
 CAknSinglePopupMenuStyleListBox* listBox = new ( ELeave ) CAknSinglePopupMenuStyleListBox;
 CleanupStack::PushL( listBox );
-iDialog = CAknPopupList::NewL(listBox, R_MPX_COLLECTION_ALBUMSONGS_LIST_CBA,
+CAknPopupList* dialog = CAknPopupList::NewL(listBox, R_MPX_COLLECTION_ALBUMSONGS_LIST_CBA,
 AknPopupLayouts::EDynMenuWindow );
-	CleanupStack::PushL( iDialog );
+	CleanupStack::PushL( dialog );
-listBox->ConstructL( iDialog,
+listBox->ConstructL( dialog,
 EAknListBoxSelectionList | EAknListBoxScrollBarSizeExcluded  );
 listBox->CreateScrollBarFrameL( ETrue );
 listBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
 if ( iSelectedMediaInAlbumView && iSelectedMediaInAlbumView->IsSupported( KMPXMediaMusicAlbum ) )
 {
 const TDesC& album = iSelectedMediaInAlbumView->ValueText( KMPXMediaMusicAlbum );
 if ( album.Compare( KNullDesC ) != 0 )
 {
-iDialog->SetTitleL( album );
+dialog->SetTitleL( album );
 }
 }
 CMPXMediaArray* songArray(const_cast<CMPXMediaArray*>( aResults.Value<CMPXMediaArray>(
 KMPXMediaArrayContents ) ) );
 }
 CTextListBoxModel* model = listBox->Model();
 model->SetItemTextArray( songList );
 model->SetOwnershipType( ELbmOwnsItemArray );
-TBool play = iDialog->ExecuteLD();
+CleanupStack::Pop( dialog );
-CleanupStack::Pop( iDialog );
+iDialog = dialog;
+TBool play( EFalse );
+GfxTransEffect::Deregister( iDialog );
+GfxTransEffect::Register( iDialog, KAppUidMusicPlayerX, EFalse );
+// Trap ExecuteLD to make sure iDialog always get reset.
+TRAP_IGNORE( play = iDialog->ExecuteLD() );
+iDialog = NULL;
 if( play )
 {
+iMediaWall->SetFlags( CHgVgMediaWall::EHgVgMediaWallDrawToWindowGC );
+iMediaWall->DrawNow();
 TInt index = listBox->CurrentItemIndex();
 // If item in list was opened, we only play the selected one.
 SaveSelectedAlbumItemL(iSelectedAlbumIndex);
 // Open the selected song of album
 UpdatePathAndOpenL(index);
 }
 else
 {
-// Do nothing if cancel was pressed.
+// Close mediawall "flip animation"
+iMediaWall->StartOpeningAnimationL( EFalse );
 }
 CleanupStack::PopAndDestroy( listBox );
-// Close mediawall "flip animation"
-iMediaWall->StartOpeningAnimationL( EFalse );
 }
 // -----------------------------------------------------------------------------
 // Shows the album songs in the tbone list.
 {
 delete iSelectedMediaInAlbumView;
 iSelectedMediaInAlbumView = NULL;
 }
+		if ( aIndex < 0 ) // We try to save a valid album otherwise restore will not work.
+			{
+			aIndex = 0;
+			}
 iSelectedMediaInAlbumView = CMPXMedia::NewL( *mediaArray.AtL( aIndex ) );
 if ( iSelectedMediaInAlbumView->IsSupported( KMPXMediaGeneralTitle ) )
 {
 const TDesC& title = iSelectedMediaInAlbumView->ValueText( KMPXMediaGeneralTitle );
 }
 CleanupStack::PopAndDestroy( unknownArtistText );
 }
-WriteToStreamFileL( iSelectedMediaInAlbumView );
+iSelectedAlbumHandler->SaveSelectedAlbum(*iSelectedMediaInAlbumView);
 }
 }
 // -----------------------------------------------------------------------------
 // CMPXCollectionViewHgContainer::RestoreSelectedAlbumItemL
 void CMPXCollectionViewHgContainer::RestoreSelectedAlbumItemL(
 const CMPXMediaArray& aMediaArray )
 {
 MPX_FUNC( "CMPXCollectionViewHgContainer::RestoreSelectedAlbumItemL" );
-CMPXMedia* restoredAlbum = CMPXMedia::NewL();
+	const CMPXMedia* restoredAlbum = iSelectedAlbumHandler->RestoreSelectedAlbum();
-CleanupStack::PushL( restoredAlbum );
+	iRestoredAlbumIndex = 0;
-ReadFromStreamFileL(restoredAlbum);
+	iSelectedAlbumIndex = 0;
-TMPXItemId id=restoredAlbum->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+	if ( restoredAlbum )
-iRestoredAlbumIndex = 0;
+		{
-iSelectedAlbumIndex = 0;
+	    TMPXItemId id=restoredAlbum->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
-for ( TInt i = 0; i < aMediaArray.Count() ; i++ )
+	    for ( TInt i = 0; i < aMediaArray.Count() ; i++ )
-{
+	        {
-CMPXMedia* currentMedia( aMediaArray.AtL( i ) );
+	        CMPXMedia* currentMedia( aMediaArray.AtL( i ) );
-if ( (currentMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) == id) ||
+	        if ( (currentMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) == id) ||
-(id.iId1 == 0 && currentMedia->ValueText(KMPXMediaGeneralTitle).Compare( restoredAlbum->ValueText(KMPXMediaGeneralTitle) ) == 0 )  )
+	             (id.iId1 == 0 && currentMedia->ValueText(KMPXMediaGeneralTitle).Compare( restoredAlbum->ValueText(KMPXMediaGeneralTitle) ) == 0 )  )
-{
+	            {
-iRestoredAlbumIndex = i;
+	            iRestoredAlbumIndex = i;
-iSelectedAlbumIndex = i;
+	            iSelectedAlbumIndex = i;
-break;
+	            break;
-}
+	            }
-}
+	        }
+		}
-CleanupStack::PopAndDestroy( restoredAlbum );
 }
 // ----------------------------------------------------------------------------
 // Write the album name, artist name and album art in media data to file
 // ----------------------------------------------------------------------------
 self->HandleLbxItemAdditionL();
 }
 return KErrNone;
 }
+// -----------------------------------------------------------------------------
+// Prepare T-bone view
+// -----------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::PrepareTboneViewL()
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::PrepareTboneViewL" );
+const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
+TInt mediaCount( mediaArray.Count() );
+HandleLbxItemRemovalL();
+iPrevContext = EContextGroupAlbum;
+iOpenAlbumTracks = ETrue;
+	iContext = EContextItemAlbum;
+	iCurrentViewType = EMPXViewTBone;
+if (ShuffleItemPresent())
+iShuffleItem = 1;
+else
+	iShuffleItem = 0;
+	TInt listCount = mediaCount + iShuffleItem;
+iThumbnailReqMap.Reset();
+iThumbnailReqMap.ReserveL(listCount);
+for ( TInt i = 0; i < listCount; i++ )
+{
+iThumbnailReqMap.Append( EFalse );
+}
+iThumbnailManager->CancelAll();
+	// MediaWall sets the default icon in the construction phase.
+	iDefaultIconSet = EFalse;
+if( !iLayoutSwitch  )
+{
+BeginFullScreenAnimation();
+}
+	RestoreSelectedAlbumItemL(mediaArray);
+	PrepareMediaWallWithListL( mediaArray, mediaCount );
+DrawableWindow()->SetOrdinalPosition( -1 );
+CleanPrevView();
+iPrevViewType = iCurrentViewType;
+if( !iDefaultIconSet )
+{
+SetDefaultIconL();
+}
+// We need to adjust the CBA for this view.
+	if( iCbaHandler )
+		iCbaHandler->UpdateCba();
+	iLayoutSwitch = EFalse;
+	}
+// -----------------------------------------------------------------------------
+// Determine if adding shuffle command is needed
+// -----------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewHgContainer::ShuffleItemPresent()
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::ShuffleItemNeeded" );
+const CMPXMediaArray& mediaArray = iListBoxArray->MediaArray();
+	TBool res = EFalse;
+	if ( mediaArray.Count() > 1 &&
+	     (iContext == EContextGroupAlbum ||
+		 iContext == EContextGroupSong ||
+		 iContext == EContextItemPlaylist ||
+		 iContext == EContextItemGenre ||
+		 iContext == EContextItemSong ))
+		{
+		res = ETrue;
+		}
+	return res;
+}
+// -----------------------------------------------------------------------------
+// Handles translation from list index to media array index
+// -----------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewHgContainer::MediaIndex(TInt aIndex) const
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::MediaIndex" );
+	TInt index(aIndex);
+	if ( iShuffleItem )
+		{
+		index = aIndex - 1;
+		}
+	return index;
+}
+// ---------------------------------------------------------------------------
+// Offer command by view, if handled, return ETrue.
+// ---------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewHgContainer::OfferCommandL( TInt aCommand )
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::OfferCommandL" );
+if( aCommand == EAknSoftkeyBack && iContext == EContextItemAlbum )
+{
+		iOpenAlbumTracks = EFalse;
+		HandleLbxItemAdditionL();
+		return ETrue;
+		}
+	else
+		{
+		return EFalse;
+		}
+}
+// ---------------------------------------------------------------------------
+// Load and set empty text
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::LoadAndSetEmptyTextL()
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::LoadAndSetEmptyTextL" );
+if ( iContext == EContextGroupAlbum )
+{
+TInt resId = R_MPX_COLLECTION_ALBUM_LBX_EMPTYTEXT;
+HBufC* emptyText = StringLoader::LoadLC( resId );
+SetLbxEmptyTextL( *emptyText );
+CleanupStack::PopAndDestroy( emptyText );
+}
+}
+// ---------------------------------------------------------------------------
+// Set previous view Uid
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::SetPreviousViewId(TUid aViewUid)
+{
+MPX_FUNC( "CMPXCollectionViewHgContainer::SetPreviousViewId" );
+	iPreviousViewId = aViewUid;
+}
+// ---------------------------------------------------------------------------
+// Prepare and begin fullscreen animation effects
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::BeginFullScreenAnimation(TBool aPrevViewWasPlayback)
+{
+if( iTranstionType != EMPXTranstionNotDefined )
+return;
+iTranstionType = EMPXTranstionToLeft;
+if ( (iPrevContext == EContextUnknown ||
+iPrevContext == EContextItemAlbum ) && aPrevViewWasPlayback )
+{
+iTranstionType = EMPXTranstionToLeft;
+}
+else if( iPrevContext == EContextUnknown )
+{
+// We aren't coming from playback view and prev context is unknown.
+// Musicplayer is propably started so we shouldn't use any animation.
+iTranstionType = EMPXTranstionNotDefined;
+return;
+}
+else if( iCurrentViewType == EMPXViewTBone )
+{
+iTranstionType = EMPXTranstionToRight;
+}
+if( iPrevViewType == EMPXViewMediawall || iPrevViewType == EMPXViewTBone )
+{
+iMediaWall->SetFlags( CHgVgMediaWall::EHgVgMediaWallDrawToWindowGC );
+iMediaWall->DrawNow();
+}
+const TInt flags = AknTransEffect::TParameter::EActivateExplicitCancel;
+TRect appRect = ((CAknAppUi*)iCoeEnv->AppUi())->ApplicationRect();
+GfxTransEffect::BeginFullScreen( iTranstionType, appRect,
+AknTransEffect::EParameterType,
+AknTransEffect::GfxTransParam(KAppUidMusicPlayerX, flags));
+}
+// ---------------------------------------------------------------------------
+// End fullscreen animation effects
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::EndFullScreenAnimation()
+{
+if( iTranstionType != EMPXTranstionNotDefined )
+{
+GfxTransEffect::EndFullScreen();
+iTranstionType = EMPXTranstionNotDefined;
+// TODO: uncomment if really needed.
+//iThumbnailManager->Pause(TTimeIntervalMicroSeconds32(KThumbLoadingPauseForTransition));
+}
+}
+// ---------------------------------------------------------------------------
+// Resolving the size of the popup list rectangle.
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewHgContainer::ResolvePopupListSizeL()
+{
+// Resolve popuplistbox rect that is used to show the album songs
+CAknSinglePopupMenuStyleListBox* listBox = new ( ELeave ) CAknSinglePopupMenuStyleListBox;
+CleanupStack::PushL( listBox );
+CMpxPopupList* dialog = CMpxPopupList::NewL(listBox, R_MPX_COLLECTION_ALBUMSONGS_LIST_CBA,
+AknPopupLayouts::EDynMenuWindow );
+CleanupStack::PushL( dialog );
+listBox->ConstructL( dialog,
+EAknListBoxSelectionList | EAknListBoxScrollBarSizeExcluded  );
+// title can be hardcoded because it is not shown to user. Just for the calculations.
+dialog->SetTitleL(_L("Foo"));
+iPopupListRect = dialog->LayoutRect();
+CleanupStack::PopAndDestroy( dialog );
+CleanupStack::PopAndDestroy( listBox );
+}
 //  End of File

branch	RCL_3
changeset 14	943ff5625028
parent 5	2a40e88564c8
child 15	171e07ac910f