/*

* Copyright (c) 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:  AknTreeListView physics handler

*

*/

#include <aknphysics.h>

#include <aknphysicsobserveriface.h>

#include <babitflags.h>

#include <eiksbobs.h>

#include <eikon.hrh> // EKeyOK

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfx.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

#include <touchfeedback.h>

#include "akntree.h"

#include "akntreelistview.h"

#include "akntreelistphysicshandler.h"

#include "akntreelist.h"

#include "akntrace.h" // trace

// Tree list view physics handler flag definitions.

enum TAknTreeListPhysicsHandlerFlags

    {

    // pressed-down highlight should be drawn to focused item

    EFlagPDHighlightToFocusedItem,

    // pressed-down highlight should be drawn to nonfocused item

    EFlagPDHighlightToNonFocusedItem,

    EFlagButtonUpReceived,

    EFlagUpdatingView

    };

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

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

// CAknTreeListPhysicsHandler::NewL

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

//

CAknTreeListPhysicsHandler* CAknTreeListPhysicsHandler::NewL(

    CAknTreeListView* aTreeListView,

    CAknTree* aTree,

    RArray<TAknTreeListViewItem>* aItems )

    {

    CAknTreeListPhysicsHandler* self = 

        CAknTreeListPhysicsHandler::NewLC( aTreeListView, aTree, aItems );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknTreeListPhysicsHandler::NewLC

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

//

CAknTreeListPhysicsHandler* CAknTreeListPhysicsHandler::NewLC( 

    CAknTreeListView* aTreeListView,

    CAknTree* aTree,

    RArray<TAknTreeListViewItem>* aItems )

    {

    CAknTreeListPhysicsHandler* self 

        = new ( ELeave ) CAknTreeListPhysicsHandler( 

            aTreeListView, aTree, aItems );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CAknTreeListPhysicsHandler::~CAknTreeListPhysicsHandler

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

//

CAknTreeListPhysicsHandler::~CAknTreeListPhysicsHandler()

    {

    delete iHighlightTimer;

    delete iPhysics;

    }

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

// CAknTreeListPhysicsHandler::HandlePointerEventL

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

//

void CAknTreeListPhysicsHandler::HandlePointerEventL(

    const TPointerEvent& aPointerEvent, const TInt& aViewLevel,

    TBool aMarking, TBool aShiftPressed, TBool aCtrlPressed )

    {

    _AKNTRACE_FUNC_ENTER;

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down && iEnableEvents )

        {

        iEventsBlocked = EFalse;

        iEnableEvents = EFalse;

        }

    if ( iEventsBlocked )

        {

        _AKNTRACE("CAknTreeListPhysicsHandler::%s Return due to event blocked", __FUNCTION__);

        _AKNTRACE_FUNC_EXIT;

	    return;

        }

    TBool listEmpty = iTree->VisibleItemCount() > 0 ? EFalse : ETrue;

    TBool eventSent = EFalse;

    // empty area events

    if ( aPointerEvent.iType == TPointerEvent::EButton1Up

             && PointerOnEmptyArea( aPointerEvent.iPosition ) )

        {

        if ( listEmpty )

            {

            // no items, empty list was clicked

            iTreeListView->ReportTreeListEvent( 

                        MAknTreeListObserver::EEmptyListClicked,

                        KAknTreeIIDNone );

            eventSent = ETrue;

            }

        else if ( iDownOnEmptyArea )

            {

            // items exist, empty list area was clicked

            iTreeListView->ReportTreeListEvent( 

                        MAknTreeListObserver::EEmptyAreaClicked,

                        KAknTreeIIDNone );

            eventSent = ETrue;

            }

        }

    if ( listEmpty || eventSent )

        {

        // return always if list is empty or if empty area event was sent

        _AKNTRACE_FUNC_EXIT;

        return;

        }   

    // Panning/flicking logic    

    // EButton1Down

    TBool wasFlicking( EFalse );

    TBool wasScrolling = ( iPhysics->OngoingPhysicsAction() != 

        CAknPhysics::EAknPhysicsActionNone );

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&

        iViewRect.Contains( aPointerEvent.iPosition ) )

        {

        iPenDown = ETrue;

        if ( iPhysics->OngoingPhysicsAction() == CAknPhysics::EAknPhysicsActionFlicking )

            {

            // flicking was ongoing when content stopped

            if ( iFeedback )

                {

                iFeedback->InstantFeedback( ETouchFeedbackBasic );

                }

            wasFlicking = ETrue;

            }

        iFlags.Clear( EFlagButtonUpReceived );

        iPosition = aPointerEvent.iPosition;

        iStartPosition = aPointerEvent.iPosition;

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        iStartTime.HomeTime();

        iHighlightTimer->Cancel();

        iItemToBeFocused = NULL;

        iIndexToBeFocused = -1;

        iItemToBeSelected = NULL;

        iPanningActivated = EFalse;

        iPlayFeedbackOnUp = EFalse;

        // Check if marquee needs to be disabled

        if ( iTreeListView->SingleClickEnabled()

                && iTree->IsMarqueeOn() )

            {

            iTree->EnableMarquee( EFalse );

            }

        iDownOnEmptyArea = PointerOnEmptyArea( aPointerEvent.iPosition );

        }

    // EDrag    

    if ( aPointerEvent.iType == TPointerEvent::EDrag )

        {

        TInt distanceFromStart( iStartPosition.iY - aPointerEvent.iPosition.iY );

        if ( !iPanningActivated && Abs( distanceFromStart ) > DragThreshold() )

            {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iTfxGc );

            if ( tfxApi )

                {

                tfxApi->EnableEffects( EFalse );

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            iPanningActivated = ETrue;   

            iDownOnEmptyArea = EFalse;

            iHighlightTimer->Cancel();

            iItemToBeFocused = NULL;

            iItemToBeSelected = NULL;

            iIndexToBeFocused = -1;

            iTreeListView->SetPressedDownState( EFalse );

            iPosition = aPointerEvent.iPosition;

            _AKNTRACE(

                "CAknTreeListPhysicsHandler::[%s] Report EEventPanningStarted",

                __FUNCTION__);

			if ( iTreeListView->SingleClickEnabled() )

                {

                iTreeListView->EnableHighlight( EFalse );

                iTreeListView->CancelLongTapDetectorL();

                }

            iTreeListView->ReportTreeListEvent( 

                MAknTreeListObserver::EEventPanningStarted,

                KAknTreeIIDNone );

            }

        if ( iPanningActivated )

            {

            TInt deltaY( iPosition.iY - aPointerEvent.iPosition.iY );

            iPosition = aPointerEvent.iPosition;

            TPoint deltaPoint( 0, deltaY );

            _AKNTRACE(

                "CAknTreeListPhysicsHandler::[%s] Panning deltaPoint.iY = %d",

                __FUNCTION__, deltaY );

            iPhysics->RegisterPanningPosition( deltaPoint );

            }

        else if ( iTreeListView->SingleClickEnabled() )

            {

            iTreeListView->LongTapPointerEventL( aPointerEvent );

            }        

        }

    // EButton1Up   

    if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

        {

        iTreeListView->SetPressedDownState( EFalse );

        if ( iTreeListView->SingleClickEnabled() && !aMarking )

            {

            iHighlightTimer->Cancel();

            iTreeListView->EnableHighlight( EFalse );

            iTreeListView->LongTapPointerEventL( aPointerEvent );

            }

        iFlags.Set( EFlagButtonUpReceived );

        iTreeListView->DrawDeferred();

        TInt distance = iStartPosition.iY - aPointerEvent.iPosition.iY;

        TPoint drag( 0, distance );

        if ( iPhysics->StartPhysics( drag, iStartTime ) )

            {

            if ( iPanningActivated )

                {

                _AKNTRACE(

                    "CAknTreeListPhysicsHandler::[%s] Report EEventPanningStopped",

                    __FUNCTION__);

                iTreeListView->ReportTreeListEvent( 

                    MAknTreeListObserver::EEventPanningStopped,

                    KAknTreeIIDNone );

                }

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            // Transitions are already suspended if listbox was panned.

            if ( !iPanningActivated )

                {

                MAknListBoxTfx* tfxApi = CAknListLoader::TfxApi( iTfxGc );

                if ( tfxApi )

                    {

                    tfxApi->EnableEffects( EFalse );

                    }

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            if ( iPhysics->OngoingPhysicsAction() == CAknPhysics::EAknPhysicsActionFlicking )

                {

                iItemToBeFocused = NULL;

                iItemToBeSelected = NULL;

                iIndexToBeFocused = -1;

                iHighlightTimer->Cancel();

                }

            if ( iItemToBeSelected != NULL )

                {

                iTreeListView->SelectItem( iItemToBeSelected );

                iItemToBeSelected = NULL;

                }     

            _AKNTRACE(

                "CAknTreeListPhysicsHandler::[%s] Report EEventFlickStarted",

                __FUNCTION__);

            iTreeListView->ReportTreeListEvent( 

                MAknTreeListObserver::EEventFlickStarted,

                KAknTreeIIDNone );

            _AKNTRACE_FUNC_EXIT;

            return;

            }

        if ( iPlayFeedbackOnUp )

            {

            // touch down has occured on an item, which requires feedback

            // also on up event -> play basic list feedback

            if ( iFeedback )

                 {

                 TTouchLogicalFeedback fbType = ETouchFeedbackList;

                 if ( iItemToBeSelected != NULL )

                     {

                     if ( iItemToBeSelected->IsLeaf() && iItemToBeSelected->IsMarkable() )

                         {

                         fbType = ETouchFeedbackCheckbox;

                         }

                     else if ( iItemToBeSelected->Node() != NULL )

                         {

                         if ( iItemToBeSelected->Node()->ChildCount() == 0 && 

                                 iItemToBeSelected->Node()->IsMarkable() )

                             {

                             fbType = ETouchFeedbackCheckbox;

                             }

                         }

                     iFeedback->InstantFeedback( iTreeListView, 

                                                 fbType,

                                                 ETouchFeedbackVibra,

                                                 aPointerEvent );

                     }

                 }

            }

        if ( iItemToBeSelected != NULL && !aMarking)

            {

            iTreeListView->SelectItem( iItemToBeSelected );

            iItemToBeSelected = NULL;

            }      

        }

    // Item handling logic    

    TPoint adjustedPosition( aPointerEvent.iPosition );

    adjustedPosition.iY += Offset();

    for ( TInt ii = 0; ii < iItems->Count(); ++ii )

        {

        CAknTreeItem* item = (*iItems)[ii].Item();

        if ( item && (*iItems)[ii].Rect().Contains( adjustedPosition ) )

            {        

            if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

                {            

                // Marking mode 

                if ( aMarking )

                    {

                    TBool drawNow = ( item == iTreeListView->FocusedItem() );    

                    if ( aShiftPressed )

                        {

                        iTreeListView->MarkItems( iTreeListView->FocusedItem(), item,

                            !item->IsMarked(), drawNow );

                        }

                    else if ( aCtrlPressed )

                        {

                        iTreeListView->MarkItem( item, !item->IsMarked(), drawNow );

                        }

                    }  

                else if ( iTreeListView->SingleClickEnabled() 

                          && !wasFlicking  )                    

                    {

                    iItemToBeSelected = item;             

                    iTreeListView->SetFocusedItem( item, ii, EFalse );

                    }

                if ( ii != iTreeListView->FocusedItemIndex() )

                    {

                    iItemToBeFocused = item;

                    iIndexToBeFocused = ii;

                    // node will be collapsed/expanded only if flicking was not ongoing

                    if ( item->Node() && !wasFlicking )

                        {

                        iItemToBeSelected = item;

                        // Pressed down highlight to nonfocused item

                        iFlags.Set( EFlagPDHighlightToNonFocusedItem );                            

                        }

                    // touch down on non-focused item, while not flicking

                    if ( iFeedback && !wasFlicking )

                        {

                        if ( item->Node() )

                            {

                            // item is a non-focused node, play basic list

                            // feedback

                            iFeedback->InstantFeedback( iTreeListView, 

                                                        ETouchFeedbackList );

                            // next up event causes for the node to collapse,

                            // play feedback on up event

                            iPlayFeedbackOnUp = ETrue;

                            }

                        else

                            {

                            // item is a non-focused leaf, play sensitive 

                            // feedback

                            iFeedback->InstantFeedback( iTreeListView, 

                                                        ETouchFeedbackSensitiveList );

                            }

                        }

                    }

                 // item will be selected only if flicking was not ongoing   

                 else if ( !wasFlicking )

                    {

                    iItemToBeSelected = item;

                    // Pressed down highlight to focused item

                    iFlags.Set( EFlagPDHighlightToFocusedItem );

                    // touch down on focused item, while not flicking

                    if ( iFeedback )

                        {

                        iFeedback->InstantFeedback( iTreeListView,

                                                    ETouchFeedbackList );

                        // next up event cause an action on the screen,

                        // play feedback on up event

                        iPlayFeedbackOnUp = ETrue;

                        }

                    }

                if ( !aMarking )

                    {

                    // timer will be launched everytime, but not

                    // if flicking was ongoing AND it was stopped by tapping 

                    // to highlighted item or to folder (=node)   

                    if ( !( wasFlicking && iItemToBeSelected != NULL ) )

                        {

                        LaunchHighlightTimer( wasScrolling );

                        }

                    }

                else

                    {

                    // Pressed down highlight or highlight timer 

                    // are not used in marking mode.

                    SetHighlight();   

                    }

                }

            (*iItems)[ii].HandlePointerEventL( aPointerEvent, aViewLevel,

                iTreeListView->Indention(), iTreeListView->IndentionWidth() );

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknTreeListPhysicsHandler::HandleScrollEventL

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

//

void CAknTreeListPhysicsHandler::HandleScrollEventL( 

    TEikScrollEvent aEventType, const TInt& aThumbPosition )

    {

    switch ( aEventType )

        {

        case EEikScrollUp:

        case EEikScrollDown:

        case EEikScrollPageUp:

        case EEikScrollPageDown:

        case EEikScrollThumbDragVert:

            {

            iScrollIndex = aThumbPosition;

            ScrollView( ETrue );

            }

        // fall through

        default:

            {

            StopPhysics();

            }

        }

    }

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

// CAknTreeListPhysicsHandler::HandleKeyEvent

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

//

void CAknTreeListPhysicsHandler::HandleKeyEvent( TInt aKeyCode )

    {

    if ( aKeyCode != EKeyLeftArrow && aKeyCode != EKeyRightArrow &&

         aKeyCode != EKeyUpArrow && aKeyCode != EKeyDownArrow && 

         aKeyCode != EKeyEnter && aKeyCode != EKeyOK )

        {

        return;

        }  

    TInt lastItem = LastVisibleItemIndex();  

    TInt firstItem = FirstVisibleItemIndex();

    TInt focusedItem = iTreeListView->FocusedItemIndex();   

    // Offset used in drawing

    TInt panningOffset = Offset();

    // When physics is activated view contains partial items 

    TInt viewOffset(

        iItemHeight * ( lastItem - firstItem + 1 ) - iViewRect.Height() + iListTopOffset );

    // Handle list top item  

    if ( panningOffset != 0 && ( firstItem == focusedItem || 

         firstItem == focusedItem + 1 ) )

        {

        iScrollIndex -= panningOffset;

        ScrollView( EFalse );