/*
* 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:  MR listpane physics impl
*
*/

#include "cmrlistpanephysics.h"
#include "cmrlistpane.h"
#include "nmrlayoutmanager.h"
#include "cmrfieldcontainer.h"

#include <aknphysics.h>

//DEBUG
#include "emailtrace.h"


namespace { // codescanner::namespace

const TInt KCustomDragTreshold( 10 );

} // namespace

// ---------------------------------------------------------------------------
// CMRListPanePhysics::CMRListPanePhysics
// ---------------------------------------------------------------------------
//
CMRListPanePhysics::CMRListPanePhysics(
        CCoeControl& aParent, 
        CMRFieldContainer& aViewControl, 
        MMRPhysicsObserver& aPhysicsObserver )
    : iParent( aParent ),
      iViewControl( aViewControl ),
      iPhysicsObserver( aPhysicsObserver )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::ConstructL
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::ConstructL()
    {
    FUNC_LOG;
    iFeatureEnabled = CAknPhysics::FeatureEnabled();
    if ( iFeatureEnabled )
        {
        // Physics: Create physics
        // Give pointer to control that should be able to flick/drag
        iPhysics = CAknPhysics::NewL( *this, &iViewControl );
        }
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::NewL
// ---------------------------------------------------------------------------
//
CMRListPanePhysics* CMRListPanePhysics::NewL( 
        CCoeControl& aParent, 
        CMRFieldContainer& aViewControl,
        MMRPhysicsObserver& aPhysicsObserver )
    {
    FUNC_LOG;
    CMRListPanePhysics* self = 
        new ( ELeave ) CMRListPanePhysics( 
                aParent, 
                aViewControl, 
                aPhysicsObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
        
// ---------------------------------------------------------------------------
// CMRListPanePhysics::~CMRListPanePhysics
// ---------------------------------------------------------------------------
//
CMRListPanePhysics::~CMRListPanePhysics()
    {
    FUNC_LOG;
    delete iPhysics;
    }
        
// ---------------------------------------------------------------------------
// CMRListPanePhysics::HandlePointerEventL
// ---------------------------------------------------------------------------
//
TBool CMRListPanePhysics::HandlePointerEventL(
        const TPointerEvent& aPointerEvent, TBool& aEventsBlocked )
    {
    FUNC_LOG;
    TBool physicsStarted( EFalse );
    if ( !iFeatureEnabled || iPhysics->OngoingPhysicsAction() ==
            CAknPhysics::EAknPhysicsActionBouncing )
        {
        return physicsStarted;
        }

    // Down
    if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
        {
        // Save start time and start point
        iStartTime.HomeTime();
        iStartPoint = aPointerEvent.iPosition;
        iDragPoint = iStartPoint;
        }
    
    // Drag
    else if ( aPointerEvent.iType == TPointerEvent::EDrag )
        {
        // Check how position was changed and report to physics
        TPoint deltaPoint( iDragPoint - aPointerEvent.iPosition );
        if( Abs( deltaPoint.iY ) < KCustomDragTreshold )
        	{
			deltaPoint.iX = 0;
			deltaPoint.iY = 0;
        	}
        
        iDragPoint = aPointerEvent.iPosition;
        iPhysics->RegisterPanningPosition( deltaPoint );
        }

    // Up
    else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
        {
        // Calculate dragging distance
        TPoint drag( iStartPoint - aPointerEvent.iPosition );
        
        if( Abs( drag.iY ) < KCustomDragTreshold )
        	{
			drag.iX = 0;
			drag.iY = 0;
        	}
        
        // Start physics
        physicsStarted = iPhysics->StartPhysics( drag, iStartTime );
        
        if( physicsStarted )
        	{
			aEventsBlocked = ETrue;
        	}
        else
        	{
			aEventsBlocked = EFalse;
        	}
        }    
    
    // Record previous pointer event
    iPreviousPointerEvent = aPointerEvent;
    
    return physicsStarted;
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::InitPhysicsL
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::InitPhysics()
    {
    FUNC_LOG;
    if ( !iFeatureEnabled )
        {
        return;
        }    
    TRect parentRect( iParent.Rect() );

    iWorldSize.iHeight = iViewControl.MinimumSize().iHeight;
    iWorldSize.iWidth = iViewControl.MinimumSize().iWidth;
    
    iViewSize.iHeight = parentRect.Height();
    iViewSize.iWidth = parentRect.Width();
    
    if( iWorldSize.iHeight < iViewSize.iHeight )
        {
    	iWorldSize.iHeight = iViewSize.iHeight;
        }
    

    
    iPhysics->ResetFriction();
    
    TRAP_IGNORE( iPhysics->InitPhysicsL( iWorldSize, iViewSize, EFalse ) );
    iPhysics->UpdateViewWindowControl( &iParent );
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::SetWorldHeight
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::SetWorldHeight( TInt aWorldHeight )
    {
    FUNC_LOG;
    if ( !iFeatureEnabled )
        {
        return;
        }    
    iWorldSize.iHeight = aWorldHeight;
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::ViewPositionChanged
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::ViewPositionChanged( const TPoint& aNewPosition,
                          TBool aDrawNow,
                          TUint /*aFlags*/ )
    {
    FUNC_LOG;
    if ( !iFeatureEnabled )
        {
        return;
        }
    if ( iPhysics->OngoingPhysicsAction() ==
            CAknPhysics::EAknPhysicsActionBouncing )
        {
        return;
        }

    iVerScrollIndex = aNewPosition.iY - iViewSize.iHeight / 2;
    
    // Parents position is taken into account, by
    // adding the extra x and y coordinates to field containers
    // new position.
    iViewControl.SetPosition( TPoint( 
            iParent.Position().iX, 
            -iVerScrollIndex + iParent.Position().iY ) );
    
    // Draw only when drawing is allowed
    if ( aDrawNow )
        {
        iParent.DrawDeferred();
        }        
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::PhysicEmulationEnded
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::PhysicEmulationEnded()
    {
    FUNC_LOG;
    iPhysicsObserver.PhysicsEmulationEnded();
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::ViewPosition
// ---------------------------------------------------------------------------
//
TPoint CMRListPanePhysics::ViewPosition() const
    {
    FUNC_LOG;
    if ( !iFeatureEnabled )
        {
        return TPoint( iParent.Position() );
        }
    
    // This is the default implementation
    TPoint viewPosition( 
            iViewSize.iWidth / 2, 
            iViewSize.iHeight / 2 + iVerScrollIndex );
    
    return viewPosition;
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::UpdateVerticalScrollIndex
// ---------------------------------------------------------------------------
//
void CMRListPanePhysics::UpdateVerticalScrollIndex( TInt aVerScrollIndex )
    {
    FUNC_LOG;
    if ( iFeatureEnabled )
        {
        // Physics' new position is updated to this member, when field 
        // container is scrolled by someone else than physics.
        iVerScrollIndex = aVerScrollIndex;
        }
    }

// ---------------------------------------------------------------------------
// CMRListPanePhysics::VerticalScrollIndex
// ---------------------------------------------------------------------------
//
TInt CMRListPanePhysics::VerticalScrollIndex()
    {
    return iVerScrollIndex;
    }
// End of file