/*

* 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

#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);