/*

* Copyright (c) 2008-2009 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:    List of media items, which has focus

*

*/

// my include

#include "glxnavigablelist.h"

// system includes

#include <mpxcollectionpath.h>

#include <glxtracer.h>

#include <glxlog.h>

// user includes

#include "glxlistutils.h"

#include "glxmedia.h"

#include "glxstaticitemlist.h"

#include "mglxnavigablelistobserver.h"

using namespace NGlxNavigableList;

namespace NGlxNavigableList

    {

    /** 

     * Strategy to process selection indexes

     */ 

    class MSelectionIndexStrategy 

        {

    public:

        /** 

         * Process a single selection index

         * @param aSelectedItemIndex index in selected item index array to process

         */ 

        virtual void Process( TInt aSelectedItemIndex ) = 0;

        };

    /** 

     * Strategy to remove selection indexes

     */ 

    NONSHARABLE_CLASS( TRemoveSelectedItemIndexStrategy ) : 

            public MSelectionIndexStrategy

        {

    public:

        /**

         * Constructor

         * @param aSelectedItemIndices Selected item index array

         */

        TRemoveSelectedItemIndexStrategy( RArray< TInt>& aSelectedItemIndices )

                : iSelectedItemIndices( aSelectedItemIndices )

            {

            }

        /** See @ref MSelectionIndexStrategy */

        void Process( TInt aSelectedItemIndex )

            {

            iSelectedItemIndices.Remove( aSelectedItemIndex );

            }

    private:

        /// Selected item indexes

        RArray< TInt>& iSelectedItemIndices; 

        };

    /** 

     * Strategy to move selection indexes

     */ 

    NONSHARABLE_CLASS( TMoveSelectedItemIndexStrategy ) : 

            public MSelectionIndexStrategy

        {

    public:

        /** 

         * Constructor 

         * @param aMoveCount a number of items to move index by

         */

        TMoveSelectedItemIndexStrategy( RArray< TInt>& aSelectedItemIndices, 

            TInt aMoveCount )

                : iSelectedItemIndices( aSelectedItemIndices )

            {

            iMoveCount = aMoveCount;

            }

        /** See @ref MSelectionIndexStrategy */

        void Process( TInt aSelectedItemIndex )

            {

            iSelectedItemIndices[ aSelectedItemIndex ] += iMoveCount;

            }

    private: 

        /// The count of items to move by

        TInt iMoveCount;

        /// Selected item indexes

        RArray< TInt>& iSelectedItemIndices; 

        };

    } // namespace NGlxNavigableList

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

// Two-phase constructor

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

//

CGlxNavigableList* CGlxNavigableList::NewL( const TGlxIdSpaceId& aIdSpaceId,

        MGlxNavigableListObserver& aObserver, MGlxMediaUser& aMediaUser )

    {

    TRACER("CGlxNavigableList::NewL");

    CGlxNavigableList* self = new (ELeave) CGlxNavigableList( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aIdSpaceId, aMediaUser );

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

CGlxNavigableList::CGlxNavigableList( MGlxNavigableListObserver& aObserver ) :

        iFocusInitialPosition( NGlxListDefs::EFocusFirst ),

        iObserver( aObserver )

    {

    TRACER("CGlxNavigableList::CGlxNavigableList");

    iFocusIndex = KErrNotFound;

    }

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

// Second-phase constructor

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

//

void CGlxNavigableList::ConstructL( const TGlxIdSpaceId& aIdSpaceId,

        MGlxMediaUser& aMediaUser )

    {

    TRACER("CGlxNavigableList::ConstructL");

    iItemList = CGlxStaticItemList::NewL( aIdSpaceId, *this, aMediaUser );

    }

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

// Destructor

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

//

CGlxNavigableList::~CGlxNavigableList()

    {

    TRACER( "CGlxNavigableList::~CGlxNavigableList" );

    iSelectedItemIndices.Close();

    delete iItemList;

    }

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

// return id space id

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

// 

const TGlxIdSpaceId& CGlxNavigableList::IdSpaceId() const

    {

    TRACER( "CGlxNavigableList::IdSpaceId");

    return iItemList->IdSpaceId();

    }

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

// Synchronise contents of the list with the collection path

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

//

void CGlxNavigableList::SetContentsL( const CMPXCollectionPath& aPath,

        const MGlxMediaPool& aMediaPool )

    {

    TRACER( "CGlxNavigableList::SetContentsL" );

    iItemList->SetContentsL( aPath, aMediaPool );

    }

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

// Re-orders contents of the list with the collection path

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

//

void CGlxNavigableList::ReorderContentsL( const CMPXCollectionPath& aPath, 

        const MGlxMediaPool& aMediaPool )

    {

    TRACER( "CGlxNavigableList::ReorderContentsL" );

    __TEST_INVARIANT;

    // List contents have been reordered. If we called SetContentsL directly,

    // the client would get semi-random (but correct) sequence of added/removed

    // notifications. To provide a cleaner notification, send only "all removed"

    // and "all added" notifications. 

    // store the focus and selection temporarily for restoring later-

    // (store ids; cannot store index, since indexes may change upon reorder)

    TGlxMediaId focusedItemId = FocusId();

    RArray< TGlxMediaId > selectedItemIds;

    CleanupClosePushL( selectedItemIds );

    SelectionL( selectedItemIds );

    // send notification "all items removed"

    ClearContentsL( aMediaPool );

    // set contents to reordered list, this removes focus and selection.

    // send notification of "all items added" (in new order)

    SetContentsL( aPath, aMediaPool );

    // restore focus and selection

    SetFocus( focusedItemId ); 

    SelectL( selectedItemIds );

    CleanupStack::PopAndDestroy( &selectedItemIds );

    __TEST_INVARIANT;

    }

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

// Remove an item form the list

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

//

void CGlxNavigableList::Remove( const TGlxIdSpaceId& aIdSpaceId, 

        const TGlxMediaId& aItemId )

    {

    TRACER( "CGlxNavigableList::Remove" );

    iItemList->Remove( aIdSpaceId, aItemId );

    }

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

// Remove any pointers to the media object at the specified index

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

//

void CGlxNavigableList::RemoveReference( TInt aIndex )

    {

    TRACER( "CGlxNavigableList::RemoveReference" );

    iItemList->RemoveReference( aIndex );

    }

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

// Add a static item

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

//

void CGlxNavigableList::AddStaticItemL( CGlxMedia* aStaticItem, 

        NGlxListDefs::TInsertionPosition aTargetPosition )

    {

    TRACER( "CGlxNavigableList::AddStaticItemL" );

    iItemList->AddStaticItemL( aStaticItem, aTargetPosition );

    }

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

// Enable/disable static items

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

//

void CGlxNavigableList::SetStaticItemsEnabled( TBool aEnabled )

    {

    TRACER( "CGlxNavigableList::SetStaticItemsEnabled" );

    iItemList->SetStaticItemsEnabled( aEnabled );

    }

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

// return ETrue if static items are enabled

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

//

TBool CGlxNavigableList::IsStaticItemsEnabled() const

    {

    TRACER( "CGlxNavigableList::IsStaticItemsEnabled");

    return iItemList->IsStaticItemsEnabled();

    }

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

// Return count

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

//

TInt CGlxNavigableList::Count( NGlxListDefs::TCountType aType ) const

    {

    TRACER( "CGlxNavigableList::Count");

    return iItemList->Count( aType );

    }

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

// Sets the initial focus position, first or last item

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

//

void CGlxNavigableList::SetFocusInitialPosition(NGlxListDefs::TFocusInitialPosition aFocusInitialPosition)

    {

    TRACER( "CGlxNavigableList::SetFocusInitialPosition");

    iFocusInitialPosition = aFocusInitialPosition;

    SetInitialFocus();

    }

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

// Return focus index

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

//

TInt CGlxNavigableList::FocusIndex() const 

    {

    TRACER( "CGlxNavigableList::FocusIndex");

    return iFocusIndex;

    }

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

// Set focus index

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

//

void CGlxNavigableList::SetFocus( NGlxListDefs::TFocusSetType aType, TInt aValue )

    {

    TRACER( "CGlxNavigableList::SetFocus");

    GLX_LOG_INFO1( "CGlxNavigableList::SetFocus: Entry: %d", aValue );

    __TEST_INVARIANT;

    // Observer callback needs to know the focus change type

    NGlxListDefs::TFocusChangeType type = NGlxListDefs::EUnknown;

    TInt oldIndex = iFocusIndex;

    switch ( aType )

        {

        case NGlxListDefs::EAbsolute:

            type = SetFocus( aValue );

            break;

        case NGlxListDefs::ERelative:

            type = MoveFocus( aValue );

            break;

        default:

            Panic( EGlxPanicIllegalArgument ); // Unsupported focus change type

            break;

        }

    // notify observer if focus changed

    NotifyFocusChange( type, oldIndex,  iFocusIndex != oldIndex );

    __TEST_INVARIANT;

    GLX_LOG_INFO( "CGlxNavigableList::SetFocusL: Exit" );

    }

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

// Set focus by id

// inline private member function only in cpp file, so will be inlined in arm

// (ok as long as called only once)

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

//

inline void CGlxNavigableList::SetFocus( const TGlxMediaId& aItemId )

    {

    TRACER( "CGlxNavigableList::SetFocus");

    TInt index = Index( IdSpaceId(), aItemId );

    if ( KErrNotFound != index )

        {

        // Focus the item if it still exists in the new list

        SetFocus( NGlxListDefs::EAbsolute, index );

        }

    }

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

// Set focus index

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

//

NGlxListDefs::TFocusChangeType CGlxNavigableList::SetFocus( TInt aIndex )

    {

    TRACER( "CGlxNavigableList::SetFocus");

    __ASSERT_ALWAYS( aIndex >= 0 && aIndex < Count(), Panic( EGlxPanicIllegalArgument ) );

    iFocusIndex = aIndex;

    // it is not possible to know which direction focus was moving, since

    // client did not specify it. Looping of the list makes it impossible to 

    // compare the old and new index. 

    return NGlxListDefs::EUnknown;

    }

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

// Move focus index

// inline private member function only in cpp file, so will be inlined in arm

// (ok as long as called only once)

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

//

inline NGlxListDefs::TFocusChangeType CGlxNavigableList::MoveFocus( TInt aDelta )

    {

    TRACER( "CGlxNavigableList::MoveFocus");

    // Moving focus in not possible when the list is empty

    if ( KErrNotFound != iFocusIndex )

        {

        // Move focus index

        iFocusIndex += aDelta;

        // wrap back into the loop

        iFocusIndex = GlxListUtils::NormalizedIndex( iFocusIndex, Count() );

        // determine direction of focus change

        if ( aDelta > 0 )

            {

            return NGlxListDefs::EForward;

            }

        // client won't be notified if aDelta is 0, so it is suitable

        // to return EBackward, even if focus does not move

        return NGlxListDefs::EBackward;

        }

    return NGlxListDefs::EUnknown;

    }

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

// Notify observers of focus change

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

//

void CGlxNavigableList::NotifyFocusChange( NGlxListDefs::TFocusChangeType aType, 

        TInt aOldIndex, TBool aNotify )

    {

    TRACER( "CGlxNavigableList::NotifyFocusChange");

    if ( aNotify )

        {

        iObserver.HandleFocusChanged( aType, iFocusIndex, aOldIndex );

        }

    }

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

// Sets the initial focus

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

//

void CGlxNavigableList::SetInitialFocus()

    {

    TRACER( "CGlxNavigableList::SetInitialFocus");

    // Only need to set focus if there are some items

    if ( Count() )

        {

        if ( iFocusInitialPosition == NGlxListDefs::EFocusFirst )

            {

            iFocusIndex = 0;

            }

        else // iFocusInitialPosition == NGlxListDefs::EFocusLast

            {

            iFocusIndex = Count() - 1;

            }

        }

    }

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

// Resets the focus to the initial position

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

//

void CGlxNavigableList::ResetFocus()

    {

    TRACER( "CGlxNavigableList::ResetFocus");

    TInt oldFocusIndex = iFocusIndex;

    SetInitialFocus();

    // notify of focus change after resetting focus

    // Only need to notify if there are some items

    if( Count() )

    	{

    NotifyFocusChange( NGlxListDefs::EUnknown, oldFocusIndex, ETrue );

    	}

    }

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

// Return item by index

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

//

TGlxMedia& CGlxNavigableList::Item( TInt aIndex )

    {

    TRACER( "CGlxNavigableList::Item");

    return iItemList->Item( aIndex );

    }

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

// Return index by id

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

//

TInt CGlxNavigableList::Index(const TGlxIdSpaceId& aIdSpaceId, const TGlxMediaId& aId ) const

    {

    TRACER( "CGlxNavigableList::Index");

    return iItemList->Index(aIdSpaceId, aId );

    }

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

// Return whether item at index is selected

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

//

TBool CGlxNavigableList::IsSelected(TInt aIndex) const

    {

    TRACER( "CGlxNavigableList::IsSelected");

    return ( KErrNotFound != iSelectedItemIndices.FindInOrder( aIndex ) );

    }

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

// Select/deselect item

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

//

void CGlxNavigableList::SetSelectedL( TInt aIndex, TBool aSelected )

    {

    TRACER( "CGlxNavigableList::SetSelectedL");    

    GLX_LOG_INFO2( "CGlxNavigableList::SetSelectedL: index %d selected %b", 

            aIndex, aSelected );

    __TEST_INVARIANT;

    if ( aSelected )

        {

        SelectL( aIndex );

        }