/*

* 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:  A list model for add tracks dialog

*

*/

// INCLUDE FILES

#include <bamdesca.h>

#include <badesca.h>

#include <f32file.h>

#include <mpxlog.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediageneraldefs.h>

#include <mpxcommonuihelper.h>

#include "mpxaddtracksdialog.hrh"

#include "mpxaddtrackslistmodel.h"

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CMPXAddTracksListModel* CMPXAddTracksListModel::NewL()

    {

    MPX_FUNC( "CMPXAddTracksListModel::NewL" );

    CMPXAddTracksListModel* self =

        new (ELeave) CMPXAddTracksListModel();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::CMPXAddTracksListModel

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CMPXAddTracksListModel::CMPXAddTracksListModel()

    :iCurrentHighlightIndex(0),

    iFindSongs( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::ConstructL()

    {

    MPX_FUNC( "CMPXAddTracksListModel::ConstructL" );

    iTracksList = CMPXMediaArray::NewL();

    iMMCDrive = CMPXCommonUiHelper::MMCDriveNumber();

    }

// -----------------------------------------------------------------------------

// Destructor.

// -----------------------------------------------------------------------------

//

CMPXAddTracksListModel::~CMPXAddTracksListModel()

    {

    MPX_DEBUG1( "CMPXAddTracksListModel::~CMPXAddTracksListModel START" );

    if ( iTracksList )

        {

        iTracksList->Reset();

        delete iTracksList;

        }

    iExpandedIndices.Reset();

    iExpandedIndices.Close();

    MPX_DEBUG1( "CMPXAddTracksListModel::~CMPXAddTracksListModel END" );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::ResetTracksList

// Reset tracks list.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::ResetTracksList()

    {

    MPX_FUNC( "CMPXAddTracksListModel::ResetTracksList" );

    iTracksList->Reset();

    iExpandedIndices.Reset();

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::TrackName

// Return track name.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

const TDesC& CMPXAddTracksListModel::TrackName( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::TrackName" );

    CMPXMedia* item( NULL );

    TInt count( iTracksList->Count() );

    if ( count > 0 && aIndex < count )

        {

        TRAP_IGNORE( item = iTracksList->AtL( aIndex ) );

        }

    return item ? item->ValueText( KMPXMediaGeneralTitle ) : KNullDesC;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::TrackTypeL

// Return track type.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::TrackTypeL( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::TrackTypeL" );

    CMPXMedia* item( NULL );

    TInt count( iTracksList->Count() );

    if ( count > 0 && aIndex < count )

        {

        item = iTracksList->AtL( aIndex );

        User::LeaveIfNull( item );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return *item->Value<TMPXGeneralType>( KMPXMediaGeneralType );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::TrackCategoryL

// Return track Category.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::TrackCategoryL( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::TrackCategoryL" );

    CMPXMedia* item( NULL );

    TInt count( iTracksList->Count() );

    if ( count > 0 && aIndex < count )

        {

        item = iTracksList->AtL( aIndex );

        User::LeaveIfNull( item );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return *item->Value<TMPXGeneralCategory>( KMPXMediaGeneralCategory );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::TrackIdL

// Return track id.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TMPXItemId CMPXAddTracksListModel::TrackIdL( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::TrackIdL" );

    CMPXMedia* item( NULL );

    TInt count( iTracksList->Count() );

    if ( count > 0 && aIndex < count )

        {

        item = iTracksList->AtL( aIndex );

        User::LeaveIfNull( item );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return *item->Value<TMPXItemId>( KMPXMediaGeneralId );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::MediaL

// Return track media.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

const CMPXMedia& CMPXAddTracksListModel::MediaL( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::MediaL" );

    TInt entriesCount( iTracksList->Count() );

    if ( ( entriesCount < aIndex + 1 ) || ( aIndex < 0 ) )

        {

        User::Leave( KErrArgument );

        }

    CMPXMedia* item( iTracksList->AtL( aIndex ) );

    User::LeaveIfNull( item );

    return *item;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::TracksListCount

// Return number of tracks stored in the list.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::TracksListCount() const

    {

    MPX_FUNC( "CMPXAddTracksListModel::TracksListCount" );

    return iTracksList->Count();

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::InsertGroupsL

// Insert groups at aPos of the tracks list.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::InsertGroupsL(

    CMPXMediaArray& aMedia, TInt aPos , TInt aCategory)

    {

    MPX_FUNC( "CMPXAddTracksListModel::InsertGroupsL" );

    TInt count = aMedia.Count();

    MPX_DEBUG2( "CMPXAddTracksListModel::InsertGroupsL MdcaCount = %d", count );

    for ( TInt index = 0; index < count; index++ )

        {

        MPX_DEBUG2( "CMPXAddTracksListModel::InsertGroupsL index = %d", index );

        CMPXMedia* origItem( aMedia.AtL( index ) );

        User::LeaveIfNull( origItem );

        CMPXMedia* item( CMPXMedia::NewL( *origItem ) );

        item->SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );

        item->SetTObjectValueL( KMPXMediaGeneralCategory, aCategory );

        if ( aPos == -1 )

            {

            iTracksList->AppendL( item );

            }

        else

            {

            iTracksList->InsertL( item, aPos + index );

            }

        }

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::InsertTrackL

// Insert track at position.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::InsertTrackL(

    CMPXMedia& aTrack, TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::InsertTrackL" );

    CMPXMedia* media = CMPXMedia::NewL( aTrack );

    iTracksList->Insert( media, aIndex );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::InsertTracksUnderGroupL

// Insert tracks under the current group. Update the expanded array too.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::InsertTracksUnderGroupL(

    CMPXMediaArray& aTracks, TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::InsertTracksUnderGroupL" );

    // Make sure the current index is a group

    if ( TrackTypeL( aIndex ) == EMPXGroup )

        {

        TInt count = aTracks.Count();

        for ( TInt i = 0; i < count; i++ )

            {

            CMPXMedia* origItem( aTracks.AtL( i ) );

            User::LeaveIfNull( origItem );

            CMPXMedia* media = CMPXMedia::NewL( *origItem );

            iTracksList->Insert( media, aIndex + 1 + i );

            }

        // Mark as expanded

        MarkExpandedL( aIndex, count );

        }

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::RemoveAllTracksFromGroupL

// Remove all tracks under group.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::RemoveAllTracksFromGroupL( TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::RemoveAllTracksFromGroupL" );

    TInt count = 0;

    if ( TrackTypeL( aIndex ) == EMPXGroup )

        {

        TInt pos = aIndex + 1;

        while ( ( pos < TracksListCount() ) &&

            ( TrackTypeL( pos ) != EMPXGroup ) )

            {

            // Remove the track from the list

            iTracksList->Remove( pos );

            count++;

            }

        // Mark as collapsed

        UnMarkExpanded( aIndex, count );

        }

    return count;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::RemoveTracks

// Remove tracks.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::RemoveTracks( TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::RemoveTracks" );

    iTracksList->Remove( aIndex );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::ExpandedGroupsCount

// Return expanded groups count.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::ExpandedGroupsCount() const

    {

    MPX_FUNC( "CMPXAddTracksListModel::ExpandedGroupsCount" );

    return iExpandedIndices.Count();

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::IsExpandedIndex

// Check if the index is expanded or not.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CMPXAddTracksListModel::IsExpandedIndex( TInt aIndex ) const

    {

    //MPX_FUNC( "CMPXAddTracksListModel::IsExpandedIndex" );

    TBool result = EFalse;

    if ( iExpandedIndices.Find( aIndex ) != KErrNotFound )

        {

        result = ETrue;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::MarkExpandedL

// Mark the current index as expanded.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::MarkExpandedL( TInt aIndex, TInt aCount )

    {

    MPX_FUNC( "CMPXAddTracksListModel::MarkExpandedL" );

    // Update the expanded array accordingly.

    TInt count = iExpandedIndices.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        TInt& temp = iExpandedIndices[ i ];

        if ( temp > aIndex )

            {

            temp += aCount;

            }

        }

    iExpandedIndices.Append( aIndex );

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::UnMarkExpanded

// Clear the current index as collapsed.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::UnMarkExpanded( TInt aIndex, TInt aCount )

    {

    MPX_FUNC( "CMPXAddTracksListModel::UnMarkExpanded" );

    TInt pos = iExpandedIndices.Find( aIndex );

    if ( pos != KErrNotFound )

        {

        iExpandedIndices.Remove( pos );

        // Update the expanded array accordingly.

        TInt count = iExpandedIndices.Count();

        for ( TInt i = 0; i < count; i++ )

            {

            TInt& temp = iExpandedIndices[ i ];

            if ( temp > aIndex )

                {

                temp -= aCount;

                }

            }

        iExpandedIndices.Compress();

        }

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::OldestExpandedGroupIndex

// Return the oldest expanded group index.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::OldestExpandedGroupIndex()

    {

    MPX_FUNC( "CMPXAddTracksListModel::OldestExpandedGroupIndex" );

    // Oldest item is always located at the top of the list

    return iExpandedIndices[ 0 ];

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::ClosestExpandedGroupIdx

// Return the closest expanded group index.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::ClosestExpandedGroupIdx( TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::ClosestExpandedGroupIdx" );

    TInt count = iExpandedIndices.Count();

    TInt result = KErrNotFound;

    for ( TInt i = 0; i < count; i++ )

        {

        TInt temp = iExpandedIndices[ i ];

        if ( ( temp <= aIndex ) &&

            ( temp > result ) )

            {

            result = temp;

            }

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::AnimationIconNum

// Return animation icon index for highlight item.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CMPXAddTracksListModel::AnimationIconNum( TInt aIndex )

    {

    //MPX_FUNC( "CMPXAddTracksListModel::AnimationIconNum" );

    TInt trackType = EMPXNoType;

    MPX_TRAPD( error, trackType = TrackTypeL( aIndex ) );

    if( ( aIndex == iCurrentHighlightIndex )

        && ( trackType != EMPXGroup )

        && ( error == KErrNone ) )

        {

        return iAnimIconNum;

        }

    else

        {

        return 0;   // no animation icon

        }

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::SetAnimationIconNum

// Set animation icon index number.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::SetAnimationIconNum(

    TInt aIndex,

    TInt aAnimIconNum )

    {

    MPX_FUNC( "CMPXAddTracksListModel::SetAnimationIconNum" );

    iCurrentHighlightIndex = aIndex;

    iAnimIconNum = aAnimIconNum;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::FindSongs

// Provide info if there is matched songs.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CMPXAddTracksListModel::FindSongs()

    {

    MPX_FUNC( "CMPXAddTracksListModel::FindSongs" );

    return iFindSongs;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::SetFindSongsFlag

// Set flag to indicate if there are mathed songs.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CMPXAddTracksListModel::SetFindSongsFlag( TBool aFindSongs )

    {

    MPX_FUNC( "CMPXAddTracksListModel::SetFindSongsFlag" );

    iFindSongs = aFindSongs;

    }

// -----------------------------------------------------------------------------

// CMPXAddTracksListModel::FindSongs

// determines if the current item is on removable drive

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CMPXAddTracksListModel::IsOnRemovableDrive( TInt aIndex )

    {

    MPX_FUNC( "CMPXAddTracksListModel::IsOnRemovableDrive" );

    CMPXMedia* entry( NULL );

    TInt count( iTracksList->Count() );

    if ( count > 0 && aIndex < count )

        {

        TRAP_IGNORE( entry = iTracksList->AtL( aIndex ) ) ;