--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpxplugins/viewplugins/views/collectionviewhg/src/mpxcollectionviewhglistboxarray.cpp Thu Dec 17 08:45:05 2009 +0200
@@ -0,0 +1,1136 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Listbox array for collection view container
+*
+*/
+
+
+// INCLUDE FILES
+#include <StringLoader.h>
+#include <gulicon.h>
+#include <AknsUtils.h>
+#include <AknUtils.h>
+#include <aknconsts.h>
+#include <AknIconArray.h>
+#include <avkon.mbg>
+#include <f32file.h>
+#include <data_caging_path_literals.hrh>
+#include <mpxmedia.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxmediaarray.h>
+#include <mpxlog.h>
+#include <mpxcollectionviewhg.mbg>
+#include <mpxcollectionpath.h> // TMPXItemId
+#include <mpxplaybackframeworkdefs.h>
+#include <mpxcollectionviewhg.rsg>
+#include <mpxuser.h>
+
+#include <mpxcommonuihelper.h>
+#include "mpxcollectionviewhg.hrh"
+#include "mpxcommoncontainer.hrh"
+#include "mpxcommonlistboxarrayobserver.h"
+#include "mpxcollectionviewhglistboxarray.h"
+
+// CONSTANTS
+_LIT( KMPXCommonListboxFormatString, "%d\t%S" );
+_LIT( KMPXTab, "\t" );
+_LIT( KMPXCollectionViewIconFile, "mpxcollectionviewhg.mbm" );
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// ---------------------------------------------------------------------------
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+CMPXCollectionViewListBoxArray* CMPXCollectionViewListBoxArray::NewL()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::NewL" );
+ CMPXCollectionViewListBoxArray* self =
+ new ( ELeave ) CMPXCollectionViewListBoxArray();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::CMPXCollectionViewListBoxArray
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CMPXCollectionViewListBoxArray::CMPXCollectionViewListBoxArray() :
+ CMPXCommonListBoxArrayBase()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor.
+// -----------------------------------------------------------------------------
+//
+CMPXCollectionViewListBoxArray::~CMPXCollectionViewListBoxArray()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::~CMPXCollectionViewListBoxArray" );
+ delete iUnknown;
+ delete iMediaOwned;
+ }
+
+// -----------------------------------------------------------------------------
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::ConstructL()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::ConstructL" );
+ iUnknown = StringLoader::LoadL(R_MPX_QTN_MP_UNKNOWN );
+ iMMCDrive = CMPXCommonUiHelper::MMCDriveNumber();
+ }
+
+// ---------------------------------------------------------------------------
+// Sets playback status
+// ---------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewListBoxArray::SetPlaybackStatusByIdL(
+ TMPXItemId aId, TMPXPlaybackState aStatus, TInt aIndex )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::SetPlaybackStatusByIdL" );
+ // fix crash when click back too quick after play a song
+ // aIndex < 0 means no icon to place, iMedia->Count() == 0 means no song, don't search
+ if ( iMedia == NULL || aIndex < 0 || iMedia->Count() == 0)
+ {
+ return SetPlaybackStatusByIndex( KErrNotFound, aStatus );
+ }
+
+ TInt index( KErrNotFound );
+ TInt count( iMedia->Count() );
+ // Search start from aIndex, then aIndex-1, aIndex+1, aIndex-2, aIndex+2
+ // until the boundary reach then search for the rest
+ if ( aIndex > count - 1 ) // remove song before the last
+ {
+ aIndex = count - 1;
+ }
+ CMPXMedia* origMedia( iMedia->AtL( aIndex ) );
+ TMPXItemId id( origMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+ if ( id == aId )
+ {
+ index = aIndex;
+ }
+ else
+ {
+ TInt upBound( ( count - 1 ) - aIndex );
+ TInt loBound( aIndex - 0 );
+ TInt biBound( Min( upBound, loBound ) );
+ for ( TInt i = 1; i <= biBound; i++ )
+ {
+ CMPXMedia* entry( iMedia->AtL( aIndex - i ) );
+ TMPXItemId id( entry->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+ if ( id == aId )
+ {
+ index = aIndex - i;
+ break;
+ }
+
+ entry = iMedia->AtL( aIndex + i );
+ id = entry->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+ if ( id == aId )
+ {
+ index = aIndex + i;
+ break;
+ }
+ }
+ if ( index == KErrNotFound && upBound != loBound ) // still not found search for the rest
+ {
+ TInt begin( ( loBound > upBound ) ? 0 : aIndex + biBound + 1 );
+ TInt end( ( loBound>upBound ) ? aIndex - biBound : count );
+ for ( TInt i = begin; i < end; i++ )
+ {
+ CMPXMedia* entry( iMedia->AtL( i ) );
+ TMPXItemId id( entry->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
+ if ( id == aId )
+ {
+ index = i;
+ break;
+ }
+ }
+ }
+ }
+ return SetPlaybackStatusByIndex( index, aStatus );
+ }
+
+// ---------------------------------------------------------------------------
+// Activates reorder mode
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::ActivateReorderMode( TBool aEnable )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::ActivateReorderMode" );
+ iReorderActivated = aEnable;
+ if ( !iMediaOwned && aEnable )
+ {
+ // make a copy of the current array so that any modification to the array
+ // does not pollute the master copy
+ MPX_TRAPD( error, iMediaOwned = CMPXMediaArray::NewL() );
+ if ( error == KErrNone )
+ {
+ TInt count( iMedia->Count() );
+ TRAP_IGNORE(
+ for ( TInt i = 0; i < count; i++ )
+ {
+ CMPXMedia* entry( iMedia->AtL( i ) );
+ iMediaOwned->AppendL( *entry );
+ } );
+ // no need to delete iMedia, we don't own it
+ // iMedia might get reset before we have a chance to delete it
+ // keep a copy of the pointer so that we can delete
+ iMedia = iMediaOwned;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Set reorder mode
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::SetReorderGrabbedMode(
+ TBool aEnable, TInt aIndex )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::SetReorderGrabbedMode" );
+ iReorder = aEnable;
+ iOriginalIndex = aIndex;
+ iMovedIndex = aIndex;
+ if ( aEnable && aIndex == iIndex )
+ {
+ // if the item currently being moved is now playing
+ // manually move the icon after it's complete, and before the result
+ // is saved to db
+ iMoveNowPlaying = ETrue;
+ }
+ else
+ {
+ iMoveNowPlaying = EFalse;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Move current reorder index
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::MoveReorderIndex( TInt aDirection )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::MoveReorderIndex" );
+ if ( iReorder )
+ {
+ if ( ( aDirection == 1 ) && ( iMovedIndex < MdcaCount() - 1 ) )
+ {
+ iMovedIndex++;
+ }
+ else if ( ( aDirection == -1 ) && ( iMovedIndex > 0 ) )
+ {
+ iMovedIndex--;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Set current reorder index
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::SetReorderIndex( TInt aIndex )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::SetReorderIndex" );
+ iMovedIndex = aIndex;
+ }
+
+// ---------------------------------------------------------------------------
+// Confirm reorder
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::ConfirmReorderL()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::ConfirmReorderL" );
+ CMPXMedia* origMedia( iMedia->AtL( iOriginalIndex ) );
+ CMPXMedia* entry( CMPXMedia::NewL( *origMedia ) );
+ iMedia->Remove( iOriginalIndex );
+ iMedia->Insert( entry, iMovedIndex ); // iMedia takes ownership
+ if ( iMoveNowPlaying )
+ {
+ iIndex = iMovedIndex;
+ iMoveNowPlaying = EFalse;
+ }
+ iOriginalIndex = KErrNotFound;
+ iMovedIndex = KErrNotFound;
+ }
+
+// ---------------------------------------------------------------------------
+// Cancel reorder
+// ---------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::CancelReorder()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::CancelReorder" );
+ iOriginalIndex = KErrNotFound;
+ iMovedIndex = KErrNotFound;
+ }
+
+// ---------------------------------------------------------------------------
+// Gets original index of currently selected item
+// ---------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewListBoxArray::GetOriginalIndex() const
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::GetOriginalIndex" );
+ return iOriginalIndex;
+ }
+
+// ---------------------------------------------------------------------------
+// Gets the index for the song that's currently playing
+// ---------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewListBoxArray::GetPlaybackIndex() const
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::GetPlaybackIndex" );
+ return iIndex;
+ }
+
+// -----------------------------------------------------------------------------
+// Indicates if Unknown entry exists in this view
+// -----------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewListBoxArray::IsCategoryUnknownExist() const
+ {
+ return iIsUnknownExist;
+ }
+
+// -----------------------------------------------------------------------------
+// Checks if the current item is a broken link
+// -----------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewListBoxArray::IsItemBrokenLinkL( TInt aIndex ) const
+ {
+ TBool ret( EFalse );
+ if ( iMedia )
+ {
+ CMPXMedia* entry( iMedia->AtL( aIndex ) );
+ TUint flags( 0 );
+ if( entry->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ flags = entry->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
+ ret = ( ( flags ) & ( KMPXMediaGeneralFlagsIsInvalid ) );
+ }
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// Checks if the current item is corrupted
+// -----------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewListBoxArray::IsItemCorruptedL( TInt aIndex ) const
+ {
+ TBool ret( EFalse );
+ if ( iMedia )
+ {
+ CMPXMedia* entry( iMedia->AtL( aIndex ) );
+ TUint flags( 0 );
+ if( entry->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ flags = entry->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
+ ret = ( ( flags ) & ( KMPXMediaGeneralFlagsIsCorrupted ) );
+ }
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::IndicationIconIndices
+// Get array of indicator icon indices at the specified view index
+// Only used when using Hitchcock container.
+// -----------------------------------------------------------------------------
+//
+RArray<TInt> CMPXCollectionViewListBoxArray::IndicatorIconIndicesL(
+ TInt aIndex )
+ {
+ RArray<TInt> iconIndices;
+
+ TInt index( GetArrayIndexForListBoxIndex( aIndex ) );
+ CMPXMedia* entry( iMedia->AtL( index ) );
+
+ TMPXGeneralType type( EMPXNoType );
+ if ( entry->IsSupported( KMPXMediaGeneralType ) )
+ {
+ type = entry->ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+ }
+ TMPXGeneralCategory category( EMPXNoCategory );
+ if ( entry->IsSupported( KMPXMediaGeneralCategory ) )
+ {
+ category = entry->ValueTObjectL<TMPXGeneralCategory>( KMPXMediaGeneralCategory );
+ }
+ TUint flags(0);
+ if ( entry->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ flags = entry->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
+ }
+
+ // reorder icon
+ if ( ( iReorder ) && ( aIndex == iMovedIndex ) )
+ {
+ iconIndices.Append( GetReorderIcon() );
+ }
+ else if ( !iReorderActivated )
+ {
+ // playback status icon
+ if ( iIndex == index )
+ {
+ switch ( iPbState )
+ {
+ case EPbStatePlaying:
+ {
+ iconIndices.Append( EMPXClvIconPlay );
+ break;
+ }
+ case EPbStatePaused:
+ {
+ iconIndices.Append( EMPXClvIconPause );
+ break;
+ }
+ default:
+ {
+ // other playback states, not handled
+ break;
+ }
+ }
+ }
+ }
+
+ if ( category == EMPXSong && type == EMPXItem )
+ {
+ if ( flags & KMPXMediaGeneralFlagsIsInvalid )
+ {
+ iconIndices.Append( EMPXClvIconBrokenTrack );
+ }
+ else if ( flags & KMPXMediaGeneralFlagsIsCorrupted )
+ {
+ iconIndices.Append( EMPXClvIconCorruptTrack );
+ }
+ else if ( flags & KMPXMediaGeneralFlagsIsDrmLicenceInvalid )
+ {
+ iconIndices.Append( EMPXClvIconDrmExpired );
+ }
+ }
+ else if ( category == EMPXPlaylist )
+ {
+ if ( flags & KMPXMediaGeneralFlagsIsInvalid )
+ {
+ iconIndices.Append( EMPXClvIconBrokenPlaylist );
+ }
+ }
+
+ TInt driveNum = ( ( flags ) & ( KMPXMediaGeneralFlagsDriveInfo ) );
+ if ( driveNum == iMMCDrive )
+ {
+ // The MMC icon is displayed in the first Indicator slot
+ iconIndices.Append( EMPXClvIconMMC );
+ }
+
+ return iconIndices;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::MdcaPoint
+// indexes into a descriptor array.
+// -----------------------------------------------------------------------------
+//
+TPtrC CMPXCollectionViewListBoxArray::MdcaPoint( TInt aIndex ) const
+ {
+ //MPX_FUNC( "CMPXCollectionViewListBoxArray::MdcaPoint" );
+ //MPX_DEBUG2( "CMPXCollectionViewListBoxArray::MdcaPoint media count %d", iMedia->Count() );
+ TPtrC item( KNullDesC );
+ TRAP_IGNORE( item.Set( GetMdcaPointL( aIndex ) ) );
+ return item;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::CreateIconArrayL
+// creates icon array.
+// -----------------------------------------------------------------------------
+//
+CAknIconArray* CMPXCollectionViewListBoxArray::CreateIconArrayL()
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::CreateIconArrayL" );
+ TParse mbmFileName;
+ mbmFileName.Set( KMPXCollectionViewIconFile,
+ &KDC_APP_RESOURCE_DIR, NULL );
+ TFileName iconFile( mbmFileName.FullName() );
+ User::LeaveIfError( MPXUser::CompleteWithDllPath( iconFile ) );
+
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+ // Prepare icon array for listbox
+ CAknIconArray* iconArray = new ( ELeave ) CAknIconArray( 27 ); // magic: array granularity
+#else
+ // Prepare icon array for listbox
+ CAknIconArray* iconArray = new ( ELeave ) CAknIconArray( 26 ); // magic: array granularity
+#endif
+
+ // Update the enums when this list is updated
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMarkedAdd,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_indi_marked_add,
+ EMbmAvkonQgn_indi_marked_add_mask);
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropEmpty,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ KAvkonBitmapFile,
+ EMbmAvkonQgn_prop_empty,
+ EMbmAvkonQgn_prop_empty_mask);
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupSongs,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_songs,
+ EMbmMpxcollectionviewhgQgn_prop_mup_songs_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupArtist,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_artist,
+ EMbmMpxcollectionviewhgQgn_prop_mup_artist_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupAlbum,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_album,
+ EMbmMpxcollectionviewhgQgn_prop_mup_album_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupPlaylist,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_playlist,
+ EMbmMpxcollectionviewhgQgn_prop_mup_playlist_mask);
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupPlaylist,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_userplayl,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_userplayl_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupPlaylistAuto,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_playlist_auto,
+ EMbmMpxcollectionviewhgQgn_prop_mup_playlist_auto_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupGenre,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_genre,
+ EMbmMpxcollectionviewhgQgn_prop_mup_genre_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupComposer,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_composer,
+ EMbmMpxcollectionviewhgQgn_prop_mup_composer_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnMenuFolderApps,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_menu_folder_apps,
+ EMbmMpxcollectionviewhgQgn_menu_folder_apps_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropMupAudio,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_mup_audio,
+ EMbmMpxcollectionviewhgQgn_prop_mup_audio_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDNone,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_corrupttrack,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_corrupttrack_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDNone,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_brokentrack,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_brokentrack_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDNone,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_brokenplayl,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_brokenplayl_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDNone,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_drm_exp,
+ EMbmMpxcollectionviewhgQgn_graf_mup_lst_drm_exp_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnPropUnknown,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_prop_unknown,
+ EMbmMpxcollectionviewhgQgn_prop_unknown_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMmcAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_indi_mmc_add,
+ EMbmMpxcollectionviewhgQgn_indi_mmc_add_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMupPlay,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_play,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_play_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMupPause,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_pause,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_pause_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMupForwAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_indi_mup_forw_add,
+ EMbmMpxcollectionviewhgQgn_indi_mup_forw_add_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMupRewAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_indi_mup_rew_add,
+ EMbmMpxcollectionviewhgQgn_indi_mup_rew_add_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMmcAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_down,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_down_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMmcAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_up,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_up_mask );
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMmcAdd,
+ KAknsIIDQsnIconColors,
+ EAknsCIQsnIconColorsCG26,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_updown,
+ EMbmMpxcollectionviewhgQgn_graf_mup_adtl_reorder_updown_mask );
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnGrafMupDlstPodcast,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_dlst_podcast,
+ EMbmMpxcollectionviewhgQgn_graf_mup_dlst_podcast_mask );
+#endif
+ AppendColorIconToArrayL( iconArray,
+ KAknsIIDQgnIndiMupRandom,
+ KAknsIIDNone,
+ EAknsMinorNone,
+ iconFile,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_shuffle,
+ EMbmMpxcollectionviewhgQgn_graf_mup_npv_icon_shuffle_mask );
+
+ return iconArray;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::AppendMediaL
+// Appends media array to the current array
+// -----------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::AppendMediaL( const CMPXMedia& aMedia )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::AppendMediaL" );
+ if ( iMediaOwned )
+ {
+ delete iMediaOwned;
+ iMediaOwned = NULL;
+ }
+ CMPXCommonListBoxArrayBase::AppendMediaL( aMedia );
+ iIsUnknownExist = EFalse;
+
+ if ( iMedia )
+ {
+ TInt entriesCount( iMedia->Count() );
+ if ( entriesCount > 0 )
+ {
+ // check if the last entry is "unknown" entry
+ // if the last entry has a length of 0, then it's
+ // "unknown" category and needs to be localized
+ CMPXMedia* origMedia( iMedia->AtL( entriesCount - 1 ) );
+ if ( origMedia->ValueText(
+ KMPXMediaGeneralTitle ).Length() == 0 )
+ {
+ iIsUnknownExist = ETrue;
+ }
+ }
+ }
+ if ( iContainerMedia )
+ {
+ if ( iContainerMedia->IsSupported( KMPXMediaGeneralTitle ) )
+ {
+ if ( iContainerMedia->ValueText(
+ KMPXMediaGeneralTitle ).Length() == 0 )
+ {
+ TMPXGeneralCategory containerCategory(
+ iContainerMedia->ValueTObjectL<TMPXGeneralCategory>(
+ KMPXMediaGeneralCategory ) );
+ HBufC* text( NULL );
+ switch ( containerCategory )
+ {
+ case EMPXArtist:
+ {
+ text = StringLoader::LoadLC(
+ R_MPX_QTN_NMP_UNKNOWN_ARTIST );
+ break;
+ }
+ case EMPXAlbum:
+ {
+ text = StringLoader::LoadLC(
+ R_MPX_QTN_MUS_TITLE_UNKNOWN_ALBUM );
+ break;
+ }
+ case EMPXGenre:
+ {
+ text = StringLoader::LoadLC(
+ R_MPX_QTN_MUS_TITLE_UNKNOWN_GENRE );
+ break;
+ }
+ case EMPXComposer:
+ {
+ text = StringLoader::LoadLC(
+ R_MPX_QTN_MUS_TITLE_UNKNOWN_COMPOSER );
+ break;
+ }
+ default:
+ {
+ text = StringLoader::LoadLC(
+ R_MPX_QTN_MP_UNKNOWN );
+ break;
+ }
+ }
+ iContainerMedia->SetTextValueL(
+ KMPXMediaGeneralTitle, *text );
+ CleanupStack::PopAndDestroy( text );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Append icon to array
+// -----------------------------------------------------------------------------
+//
+void CMPXCollectionViewListBoxArray::AppendColorIconToArrayL(
+ CAknIconArray* aArray,
+ const TAknsItemID& aID,
+ const TAknsItemID& aColorId,
+ TInt aColorIndex,
+ const TDesC& aMbmFile,
+ TInt aBitmapId,
+ TInt aMaskId )
+ {
+ MAknsSkinInstance* skin( AknsUtils::SkinInstance() );
+
+ CFbsBitmap* bitmap( NULL );
+ CFbsBitmap* mask( NULL );
+
+ if ( aColorId == KAknsIIDNone )
+ {
+ // do not use theme color, use the default color from the file
+ AknsUtils::CreateIconLC( skin, aID,
+ bitmap, mask, aMbmFile, aBitmapId, aMaskId );
+ }
+ else
+ {
+ // use theme color
+ AknsUtils::CreateColorIconLC( skin, aID, aColorId, aColorIndex,
+ bitmap, mask, aMbmFile, aBitmapId, aMaskId, KRgbBlack );
+ }
+
+ CGulIcon* icon = CGulIcon::NewL( bitmap, mask );
+ icon->SetBitmapsOwnedExternally( EFalse );
+
+ // icon now owns the bitmaps, no need to keep on cleanup stack.
+ CleanupStack::Pop( 2 ); // mask, bitmap
+
+ CleanupStack::PushL( icon );
+ aArray->AppendL( icon );
+ // aArray now owns the icon, no need to delete.
+ CleanupStack::Pop( icon );
+ }
+
+// -----------------------------------------------------------------------------
+// Maps list box index to array index in reorder mode
+// -----------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewListBoxArray::GetArrayIndexForListBoxIndex(
+ TInt aIndex ) const
+ {
+ TInt index( aIndex );
+
+ if ( ( iReorder ) && ( iOriginalIndex != iMovedIndex ) )
+ {
+ if ( iMovedIndex > iOriginalIndex )
+ {
+ // moved down
+ if ( aIndex < iOriginalIndex )
+ {
+ // do nothing
+ }
+ else if ( aIndex > iMovedIndex )
+ {
+ // do nothing
+ }
+ else if ( aIndex < iMovedIndex )
+ {
+ // between original index and moved index
+ index = aIndex + 1;
+ }
+ else if ( aIndex == iMovedIndex )
+ {
+ index = iOriginalIndex;
+ }
+ }
+ else
+ {
+ // moved up
+ if ( aIndex > iOriginalIndex )
+ {
+ // do nothing
+ }
+ else if ( aIndex < iMovedIndex )
+ {
+ // do nothing
+ }
+ else if ( aIndex > iMovedIndex )
+ {
+ // between original index and moved index
+ index = aIndex - 1;
+ }
+ else if ( aIndex == iMovedIndex )
+ {
+ index = iOriginalIndex;
+ }
+ }
+ }
+
+ return index;
+ }
+
+// -----------------------------------------------------------------------------
+// Get reorder icon
+// -----------------------------------------------------------------------------
+//
+TBool CMPXCollectionViewListBoxArray::GetReorderIcon() const
+ {
+ TInt icon( EMPXClvIconNone );
+
+ // Determine the icon to display
+ if ( iReorder )
+ {
+ if ( iMovedIndex == 0 )
+ {
+ icon = EMPXClvIconReorderDown;
+ }
+ else if ( MdcaCount() - 1 == iMovedIndex )
+ {
+ icon = EMPXClvIconReorderUp;
+ }
+ else
+ {
+ icon = EMPXClvIconReorderUpDown;
+ }
+ }
+ return icon;
+ }
+
+// -----------------------------------------------------------------------------
+// CMPXCollectionViewListBoxArray::GetMdcaPointL
+// indexes into a descriptor array.
+// -----------------------------------------------------------------------------
+//
+TPtrC CMPXCollectionViewListBoxArray::GetMdcaPointL( TInt aIndex ) const
+ {
+ TInt index( GetArrayIndexForListBoxIndex( aIndex ) );
+ TPtrC item( KNullDesC );
+ CMPXMedia* entry( iMedia->AtL( index ) );
+ if( entry->IsSupported( KMPXMediaGeneralTitle ) )
+ {
+ TPtrC title( entry->ValueText( KMPXMediaGeneralTitle ) );
+ if ( IsCategoryUnknownExist() && aIndex== MdcaCount() - 1 && title.Length()==0 )
+ {
+ title.Set( *iUnknown );
+ }
+
+ TMPXGeneralType type( EMPXNoType );
+ if( entry->IsSupported( KMPXMediaGeneralType ) )
+ {
+ type = entry->ValueTObjectL<TMPXGeneralType>( KMPXMediaGeneralType );
+ }
+ TMPXGeneralCategory category( EMPXNoCategory );
+ if( entry->IsSupported( KMPXMediaGeneralCategory ) )
+ {
+ category = entry->ValueTObjectL<TMPXGeneralCategory>(
+ KMPXMediaGeneralCategory );
+ }
+ TUint flags(0);
+ if( entry->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ flags = entry->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
+ }
+ //MPX_DEBUG3( "CMPXCollectionViewListBoxArray::MdcaPoint (%d) Name: %S", aIndex, &title );
+ //MPX_DEBUG4( "CMPXCollectionViewListBoxArray::MdcaPoint (%d) Type: %d, Category: %d", aIndex, type, category );
+ TInt iconID( EMPXClvIconNone );
+ switch( category )
+ {
+ case EMPXSong:
+ {
+ if ( type == EMPXGroup )
+ {
+ iconID = EMPXClvIconSongs;
+ }
+ else
+ {
+ TUint flags(0);
+ if( entry->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ flags = entry->ValueTObjectL<TUint>( KMPXMediaGeneralFlags );
+ }
+ if ( flags & KMPXMediaGeneralFlagsIsInvalid )
+ {
+ iconID = EMPXClvIconBrokenTrack;
+ }
+ else if ( flags & KMPXMediaGeneralFlagsIsCorrupted )
+ {
+ iconID = EMPXClvIconCorruptTrack;
+ }
+ else if ( flags & KMPXMediaGeneralFlagsIsDrmLicenceInvalid )
+ {
+ iconID = EMPXClvIconDrmExpired;
+ }
+ else
+ {
+ iconID = EMPXClvIconAudio;
+ }
+ }
+ break;
+ }
+ case EMPXArtist:
+ {
+ iconID = EMPXClvIconArtist;
+ break;
+ }
+ case EMPXAlbum:
+ {
+ iconID = EMPXClvIconAlbum;
+ if ( entry->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) ==
+ iContainerMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) )
+ {
+ // if id == containerid, "all" under artist/album
+ iconID = EMPXClvIconSongs;
+ }
+ break;
+ }
+ case EMPXPlaylist:
+ {
+ if ( flags & KMPXMediaGeneralFlagsIsInvalid )
+ {
+ iconID = EMPXClvIconBrokenPlaylist;
+ }
+ else
+ {
+ if ( type == EMPXGroup )
+ {
+ iconID = EMPXClvIconPlaylist;
+ }
+ else
+ {
+ iconID = EMPXClvIconUserPlaylist;
+ }
+ if ( type == EMPXItem )
+ {
+ if ( entry->IsSupported(
+ KMPXMediaGeneralNonPermissibleActions ) )
+ {
+ // check for auto playlist and display a different icon
+ TMPXGeneralNonPermissibleActions attr(
+ entry->ValueTObjectL<TMPXGeneralNonPermissibleActions>(
+ KMPXMediaGeneralNonPermissibleActions ) );
+ if ( attr & EMPXWrite )
+ {
+ iconID = EMPXClvIconPlaylistAuto;
+ }
+ }
+ }
+ }
+ break;
+ }
+ case EMPXGenre:
+ {
+ iconID = EMPXClvIconGenre;
+ break;
+ }
+ case EMPXComposer:
+ {
+ iconID = EMPXClvIconComposer;
+ break;
+ }
+#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU
+ case EMPXPodcast:
+ {
+ iconID = EMPXClvIconPodcasts;
+ break;
+ }
+#endif
+ case EMPXFile:
+ {
+ // a group of files is a folder
+ iconID = EMPXClvIconFolder;
+ break;
+ }
+
+ default:
+ {
+ // unknown folder icon
+ iconID = EMPXClvIconUnknowFile;
+ break;
+ }
+ }
+ TPtr ptr = iItem->Des();
+ ptr.Zero();
+
+ ptr.Format( KMPXCommonListboxFormatString, iconID, &title );
+
+ iconID = EMPXClvIconNone;
+ // reorder icon
+ if ( ( iReorder ) && ( aIndex == iMovedIndex ) )
+ {
+ iconID = GetReorderIcon();
+ }
+ else if ( !iReorderActivated )
+ {
+ // playback status icon
+ if ( iIndex == index )
+ {
+ switch ( iPbState )
+ {
+ case EPbStatePlaying:
+ {
+ iconID = EMPXClvIconPlay;
+ break;
+ }
+ case EPbStatePaused:
+ {
+ iconID = EMPXClvIconPause;
+ break;
+ }
+ case EPbStateSeekingForward:
+ {
+ iconID = EMPXClvIconForward;
+ break;
+ }
+ case EPbStateSeekingBackward:
+ {
+ iconID = EMPXClvIconRewind;
+ break;
+ }
+ default:
+ {
+ // other playback states, not handled
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ // Do nothing
+ }
+
+ if ( iconID != EMPXClvIconNone )
+ {
+ ptr.Append( KMPXTab );
+ ptr.AppendNum( iconID );
+ }
+
+ // mmc icon
+ TInt driveNum = ( ( flags ) & ( KMPXMediaGeneralFlagsDriveInfo ) );
+ if ( driveNum == iMMCDrive )
+ {
+ ptr.Append( KMPXTab );
+ ptr.AppendNum( EMPXClvIconMMC );
+ }
+
+ item.Set( *iItem );
+ }
+ return item;
+ }
+
+// ---------------------------------------------------------------------------
+// Sets playback status
+// ---------------------------------------------------------------------------
+//
+TInt CMPXCollectionViewListBoxArray::SetPlaybackStatusByIndex(
+ TInt aIndex, TMPXPlaybackState aStatus )
+ {
+ MPX_FUNC( "CMPXCollectionViewListBoxArray::SetPlaybackStatusByIndex" );
+ TInt ret( iIndex );
+ iIndex = aIndex;
+
+ // Not to display seeking icons for seeking mode
+ if ( aStatus != EPbStateSeekingForward &&
+ aStatus != EPbStateSeekingBackward )
+ {
+ iPbState = aStatus;
+ }
+ return ret;
+ }
+
+// End of File