/*

* Copyright (c) 1997-2010 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 box implementation.

*

*/

#include <e32base.h>

#include <e32keys.h>

#include <bamatch.h>

#include <badesca.h>

#include <barsread.h>

#include <eiklbx.h>

#include <eiklbv.h>

#include <eiklbi.h>

#include <eiklbm.h>

#include <eikenv.h>

#include <eiklbx.pan>

#include <gulbordr.h>

#include <eikbutb.h>

#include <coemain.h>

#include <w32std.h>

#include <gulutil.h>

#include <uikon.hrh>

#include <eikkeys.h>

//#include <laflistb.h>

#include <laflbx.h>

#include <eikpanic.h>

#include <eikcmobs.h>

// Needed to use MopGetObject

#include <coemop.h>

#include <eikmenub.h> 

#include <AknLayout.lag>

#include <aknenv.h>

#include <AknDef.h>

#include <AknUtils.h>

#include <aknappui.h>

#include <aknPopup.h>

#include <AknTasHook.h>

// For hash key marking.

#include <e32property.h>

#include <featmgr.h>

#include <centralrepository.h>

#include <cenrepnotifyhandler.h>

#include <AknFepInternalCRKeys.h> // KAknFepHashKeySelection

#include <AvkonInternalCRKeys.h>  // KAknQwertyInputModeActive

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknphysics.h>

#include <aknphysicsobserveriface.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION

#include <aknlistloadertfx.h>

#include <aknlistboxtfx.h>

#endif

#include <touchfeedback.h>

#include <akncollection.h>

#include <aknitemactionmenu.h>

#include <aknlongtapdetector.h>

#include <AknPriv.hrh>

#include <aknmarkingmodeobserver.h>

#include "akntrace.h"

// timeout for long keypress used in markable lists

const TInt KLongPressInterval = 600000; // 0,6 seconds

const TInt KEikListBoxPointerRepeatInterval = 100000;  // in micro conds (= 0.1 secod)

// Maximum scroll speed ( max amount of items moved one time )

const TInt KDefaultMaxSpeed = 30;

const TInt KDefaultStepSpeed = 5;

const TInt KEikListBoxInvalidIndex=-1;

//interval time for disable second point event

const TInt KTwoPointerUpEventInterval = 120;    //  120 millisecond ( = 0.12 second )

const TInt KPointerDownAndUpThreshold = 5;

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

// If a parent to the supplied control has its Gc set, this function will find 

// it and return it.

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

//

LOCAL_C CWindowGc* ReplaceGcWithCustomGc( const CEikListBox* aListBox )

    {

    _AKNTRACE_FUNC_ENTER;

    const CCoeControl* parent = aListBox;

    CWindowGc* customGc;

    while(parent)

        {

        customGc = parent->GetGc();

        if ( customGc )

            {

            CListItemDrawer* itemDrawer = aListBox->View()->ItemDrawer();

            CWindowGc* originalGc = itemDrawer->Gc();

            if ( customGc == originalGc )

            {

                _AKNTRACE_FUNC_EXIT;

                return NULL;

                }

            else

                {

                itemDrawer->SetGc( customGc );

                _AKNTRACE_FUNC_EXIT;

                return originalGc;

                }

            }

        parent = parent->Parent();

        }

    _AKNTRACE_FUNC_EXIT;

    return NULL;

    }

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

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

// Helper function that selects list items

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

//

LOCAL_C void SelectL( CListBoxView* aView, MAknListBoxTfxInternal* transApi, TInt aIndex, TBool select, TBool force = EFalse )

    {

    _AKNTRACE_FUNC_ENTER;

    if ( aView->ItemIsSelected( aIndex ) == select )

        {

        if ( force || transApi->SetPosition( MAknListBoxTfxInternal::EListItem, aView->ItemPos( aIndex ), aIndex ) != KErrNone )

            {

            aView->DrawItem( aIndex );

            }

        }

    else if ( select )

        {

        if ( aIndex >= aView->TopItemIndex() && aIndex <= aView->BottomItemIndex() )

            {

            aView->SelectItemL( aIndex );

            }

        else if ( !transApi->Exist( MAknListBoxTfxInternal::EListItem, aIndex ) )

            {

            aView->SelectItemL( aIndex );

            }

        else

            {

            TInt topItemIndex = aView->TopItemIndex();

            aView->SetTopItemIndex( aIndex );

            aView->SelectItemL( aIndex );

            aView->SetTopItemIndex( topItemIndex );

            }

        }

    else

        {

        if ( aIndex >= aView->TopItemIndex() && aIndex <= aView->BottomItemIndex() )

            {

            aView->DeselectItem( aIndex );

            }

        else if ( !transApi->Exist( MAknListBoxTfxInternal::EListItem, aIndex ) )

            {

            aView->DeselectItem( aIndex );

            }

        else

            {

            TInt topItemIndex = aView->TopItemIndex();

            aView->SetTopItemIndex( aIndex );

            aView->DeselectItem( aIndex );

            aView->SetTopItemIndex( topItemIndex );

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

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

// Helper function that updates list item selections

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

//

LOCAL_C void UpdateSelectionsL( CListBoxView* aView, MAknListBoxTfxInternal* transApi, TInt aHl, TInt aOld, TInt aAnchor, TBool aSelect )

    {

    _AKNTRACE_FUNC_ENTER;

    if ( aHl < aOld )

        {

        // Going up

        if ( aOld <= aAnchor )

            {

            // Going up away

            SelectL( aView, transApi, aOld, aSelect, ETrue );

            for ( TInt i = aOld - 1; i > aHl; i-- )

                {

                SelectL( aView, transApi, i, aSelect );

                }

            SelectL( aView, transApi, aHl, aSelect, ETrue );

            }

        else if ( aHl >= aAnchor )

            {

            // Going up against

            for ( TInt i = aOld; i > aHl; i-- )

                {

                SelectL( aView, transApi, i, !aSelect );

                }

            SelectL( aView, transApi, aHl, aSelect, ETrue );

            }

        else

            {

            // Passing anchor

            for ( TInt i = aOld; i > aAnchor; i-- )

                {

                SelectL( aView, transApi, i, !aSelect );

                }

            for ( TInt i = aAnchor; i >= aHl; i-- )

                {

                SelectL( aView, transApi, i, aSelect );

                }

            }

        for ( TInt i = aView->BottomItemIndex(); i >= aView->TopItemIndex(); i-- )

            {

            if ( i < aHl || i > aOld )

                {

                if ( transApi->SetPosition( MAknListBoxTfxInternal::EListItem, aView->ItemPos( i ), i ) != KErrNone )

                    {

                    aView->DrawItem( i );

                    }

                }

            }

        }

    else if ( aHl >= aOld )

        {

        // Going down

        if ( aOld >= aAnchor )

            {

            // Going down away

            SelectL( aView, transApi, aOld, aSelect, ETrue );

            for ( TInt i = aOld + 1; i < aHl; i++ )

                {

                SelectL( aView, transApi, i, aSelect );

                }

            SelectL( aView, transApi, aHl, aSelect, ETrue );

            }

        else if ( aHl <= aAnchor )

            {

            // Going down against

            for ( TInt i = aOld; i < aHl; i++ )

                {

                SelectL( aView, transApi, i, !aSelect );

                }

            SelectL( aView, transApi, aHl, aSelect, ETrue );

            }

        else

            {

            // Passing anchor

            for ( TInt i = aOld; i < aAnchor; i++ )

                {

                SelectL( aView, transApi, i, !aSelect );

                }

            for ( TInt i = aAnchor; i <= aHl; i++ )

                {

                SelectL( aView, transApi, i, aSelect );

                }

            }

        for ( TInt i = aView->BottomItemIndex(); i >= aView->TopItemIndex(); i-- )

            {

            if ( i > aHl || i < aOld )

                {

                if ( transApi->SetPosition( MAknListBoxTfxInternal::EListItem, aView->ItemPos( i ), i ) != KErrNone )

                    {

                    aView->DrawItem( i );

                    }

                }

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

//

// class CMatchBuffer

//

NONSHARABLE_CLASS(CMatchBuffer) : public CBase

    {   

public:

    enum TExtent

        { EFull, EMinimal };

public:

    static CMatchBuffer* NewL(TExtent aExtent);

    ~CMatchBuffer();

    void ConstructMatchBufferL();

public:

    RIncrMatcherBase* iMatchBuffer;

    TInt iPressedIndex; 

    TBool iDragToAnotherItem; 

    };

CMatchBuffer* CMatchBuffer::NewL(TExtent aExtent)

    {

    CMatchBuffer* buffer=new(ELeave) CMatchBuffer;

    if (aExtent==EFull)

        {

        CleanupStack::PushL(buffer);

        buffer->iMatchBuffer=new(ELeave)RIncrMatcherBuf<CEikListBox::KEikMaxMatchingBufferLength>;

        CleanupStack::Pop( buffer );

        }

    return buffer;

    }

CMatchBuffer::~CMatchBuffer()

    {

    delete iMatchBuffer;

    }

void CMatchBuffer::ConstructMatchBufferL()

    {

    iMatchBuffer=new(ELeave)RIncrMatcherBuf<CEikListBox::KEikMaxMatchingBufferLength>;

    }

//

// class CLBMSKCommandObserver

//

NONSHARABLE_CLASS(CLBMSKCommandObserver) : public MEikCommandObserver

    {

public:

    CLBMSKCommandObserver(CEikButtonGroupContainer *aCba, CEikListBox *aListBox);

    void ProcessCommandL(TInt aCommandId);

    CEikButtonGroupContainer *iCba;

    CEikListBox *iListBox;

    TInt iCurrentResource;

    };

CLBMSKCommandObserver::CLBMSKCommandObserver(CEikButtonGroupContainer *aCba, CEikListBox *aListBox)

     : iCba(aCba), iListBox(aListBox)

    {

    }

void CLBMSKCommandObserver::ProcessCommandL(TInt aCommandId)

    {

    switch ( aCommandId )

        {

        case EAknSoftkeyMark:

            {

            TInt index = iListBox->CurrentItemIndex();

            iListBox->View()->SelectItemL(index);

            iCba->SetCommandL(3,R_AVKON_SOFTKEY_UNMARK);

            iCba->DrawNow();

            iCurrentResource = R_AVKON_SOFTKEY_UNMARK;        

            }

            break;

        case EAknSoftkeyUnmark:

            {

            TInt index = iListBox->CurrentItemIndex();

            iListBox->View()->DeselectItem(index);

            iCba->SetCommandL(3,R_AVKON_SOFTKEY_MARK);

            iCba->DrawNow();

            iCurrentResource = R_AVKON_SOFTKEY_MARK;        

            }

            break;

        case EAknSoftkeyShiftMSK:

            {

            iListBox->DoShiftMSKMarkingL();

            }

            break;

        default:

            break;

        }

    }

//

// class CListBoxExt

//

NONSHARABLE_CLASS(CListBoxExt) : public CBase, public MListVisibilityObserver,

    public MCenRepNotifyHandlerCallback,

    public MAknPhysicsObserver,

    public MAknCollection,

    public MAknMarkingCollection,

    public MAknLongTapDetectorCallBack

    {

public:

    static CListBoxExt* NewL(CEikListBox& aListBox);

    ~CListBoxExt();

    // new functions

    void CreateMatchBufferL();

    void CheckCreateBufferL();

    CMatchBuffer* Buffer() const;

    TBool IsMatchBuffer() const;

    void SetReasonForFocusLost(CEikListBox::TReasonForFocusLost aReasonForFocusLost);

    CEikListBox::TReasonForFocusLost ReasonForFocusLost() const;

    /// @since 3.0

    void AddItemChangeObserverL( MListBoxItemChangeObserver* aObserver );

    /// @since 3.0

    TBool RemoveItemChangeObserver( MListBoxItemChangeObserver* aObserver );

    /// @since 3.0

    void FireItemChange(CEikListBox* aListBox);

    void CreateMSKObserverL(CEikButtonGroupContainer *aCba, 

                                     CEikListBox *aListBox);

    void RemoveMSKObserver(CEikListBox *aListBox);

    // @since 3.2

    void AddSelectionObserverL( MListBoxSelectionObserver* aObserver );

    TBool RemoveSelectionObserver( MListBoxSelectionObserver* aObserver );

    // Starts the long press timer.

    void StartLongPressTimerL();

    TBool IsInIgnoreRect( const TPoint& aPoint ) const;

    //Tests the item needs to handle all point event or not.

    TBool IsInHandleAllPointEventArray(const TInt aIndex);

public: // from MListVisibilityObserver

    TBool IsVisible() const;

    void SetUpdateScrollBarsColors(TBool aUpdate);

    TBool UpdateScrollBarsColors() const;

public: // from MCenRepNotifyHandlerCallback

    void HandleNotifyInt(TUint32 aId, TInt aNewValue);

public: // MAknPhysicsObserver

    virtual void ViewPositionChanged( const TPoint& aNewPosition,

                                      TBool aDrawNow = ETrue,

                                      TUint aFlags = 0 );

    virtual void PhysicEmulationEnded();

    virtual TPoint ViewPosition() const;

// From MAknCollection

    /**

     * Returns the collection state. The state is combination of

     * flags defined in MAknCollection::TStateFlag. 

     *

     * @return  Collection state.

     */

    TUint CollectionState() const;

    /**

     * Notifies that item action menu (CAknItemActionMenu)

     * was closed. 

     */

    void ItemActionMenuClosed();

    /** 

     * Extension function.

     *

     * @param  aExtensionId  Extension id. 

     * @param  a0            First extension method parameter.

     * @param  a1            Second extension method parameter.

     */    

    TInt CollectionExtension( TUint aExtensionId, TAny*& a0, TAny* a1 );

// From MAknMarkingCollection

    /**

     * Sets multiple marking state.

     *

     * @param aActive ETrue if multiple marking should be active.

     */

    void SetMultipleMarkingState( TBool aActive );

    /**

     * Returns whether the observer accepts ending of marking mode

     * 

     * @return ETrue if observer accepts exiting marking mode

     */

    TBool ExitMarkingMode();

    /**

     * Returns the collection marking state. The state is combination of

     * flags defined in @c TStateFlag. 

     *

     * @return  Collection state.

     */

    TUint MarkingState() const;

    /**

     * Marks the currently selected item.

     */

    void MarkCurrentItemL();

    /**

     * Marks all items in the collection.

     */

    void MarkAllL(); 

    /**

     * Unmarks all items in the collection.

     */

    void UnmarkAll();

    /*

     * Can current item be marked

     * 

     * @return ETrue if item can be marked

     */

    TBool CurrentItemMarkable();

// From MAknLongTapDetectorCallBack

    /**

     * Long tap detector callback 

     *

     * @param aPenEventLocation Long tap event location relative to parent control.

     * @param aPenEventScreenLocation Long tap event location relative to screen.

     */

    void HandleLongTapEventL( const TPoint& aPenEventLocation,

                              const TPoint& aPenEventScreenLocation );

// New single click related methods

    /**

     * Reports collection change event.

     */

    void ReportCollectionChangedEvent();

    /**

     * Enables or disables the highlight 

     * @param aEnabled ETrue to enable EFalse to disable

     * @param aPointerEnabled ETrue if highlight was enabled by pointer event.

     */

    void EnableHighlight( TBool aEnabled, TBool aPointerEnabled = EFalse );

    /**

     * Sets the highlight for the first item visible after single click