/*
* 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:  Taskswitcher physics
 *
*/

#include <aknphysics.h>

#include "tsphysicsengine.h"
#include "tsphysics.h"

// -----------------------------------------------------------------------------
// CTsPhysicsHandler::CTsPhysicsHandler
// -----------------------------------------------------------------------------
//
CTsPhysicsEngine::CTsPhysicsEngine()
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::~CTsPhysicsEngine
// -----------------------------------------------------------------------------
//
CTsPhysicsEngine::~CTsPhysicsEngine()
    {
    delete iTaskswitcherPhysics;
    delete iPhysics;
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::NewLC
// -----------------------------------------------------------------------------
//
CTsPhysicsEngine* CTsPhysicsEngine::NewLC(
        MAknPhysicsObserver& aPhysicObserver, CCoeControl& aViewControl)
    {
    CTsPhysicsEngine* self = new (ELeave) CTsPhysicsEngine();
    CleanupStack::PushL(self);
    self->ConstructL(aPhysicObserver, aViewControl);
    return self;
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::NewL
// -----------------------------------------------------------------------------
//
CTsPhysicsEngine* CTsPhysicsEngine::NewL(
        MAknPhysicsObserver& aPhysicObserver, CCoeControl& aViewControl)
    {
    CTsPhysicsEngine* self = CTsPhysicsEngine::NewLC(
            aPhysicObserver, aViewControl);
    CleanupStack::Pop(); // self;
    return self;
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::ConstructL
// -----------------------------------------------------------------------------
//
void CTsPhysicsEngine::ConstructL(MAknPhysicsObserver& aPhysicObserver,
        CCoeControl& aViewControl)
    {
    iPhysics = CAknPhysics::NewL(aPhysicObserver, &aViewControl);//TODO:
    iTaskswitcherPhysics = CTsPhysics::NewL(aPhysicObserver);
    }


// -----------------------------------------------------------------------------
// CTsPhysicsEngine::IsRunning
// -----------------------------------------------------------------------------
//
TBool CTsPhysicsEngine::IsRunning() const
    {
    return iPhysics->OngoingPhysicsAction() != CAknPhysics::EAknPhysicsActionNone;
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::HandleDragEvent
// -----------------------------------------------------------------------------
//
void CTsPhysicsEngine::HandleDragEvent(
        AknTouchGestureFw::MAknTouchGestureFwDragEvent& aEvent)
    {
    if (AknTouchGestureFw::EAknTouchGestureFwStart == aEvent.State())
        {
        iPhysics->StopPhysics();
        iStartTime.HomeTime();
        iStartPosition = aEvent.CurrentPosition();
        iDragDirection = 0;
        }
    else if (AknTouchGestureFw::EAknTouchGestureFwOn == aEvent.State())
        {
        TInt direction =
                aEvent.CurrentPosition().iX > aEvent.PreviousPosition().iX ? -1 : 1;
        TPoint deltaPoint(aEvent.PreviousPosition() - aEvent.CurrentPosition());
        iPhysics->RegisterPanningPosition(deltaPoint);
        if (iDragDirection && iDragDirection != direction)
            {
            iStartTime.HomeTime();
            iStartPosition = aEvent.PreviousPosition();
            }
        iDragDirection = direction;
        }
    else //AknTouchGestureFw::EAknTouchGestureFwStop
        {
        TPoint drag(iStartPosition - aEvent.CurrentPosition());
        iPhysics->StartPhysics(drag, iStartTime);
        if( Abs(drag.iX) < iPhysics->DragThreshold() &&
            (TInt)CAknPhysics::EAknPhysicsActionBouncing != 
            iPhysics->OngoingPhysicsAction() )
            {
            iPhysics->StopPhysics();
            }
        }
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::Stop
// -----------------------------------------------------------------------------
//
void CTsPhysicsEngine::Stop()
    {
    iPhysics->StopPhysics();
    iTaskswitcherPhysics->StopPhysics();
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::AnimateToTargetL
// -----------------------------------------------------------------------------
//
void CTsPhysicsEngine::AnimateToTarget(const TPoint& aPoint)
    {
    iTaskswitcherPhysics->StartPhysics(aPoint);
    }

// -----------------------------------------------------------------------------
// CTsPhysicsEngine::ReInitPhysicsL
// -----------------------------------------------------------------------------
//
void CTsPhysicsEngine::ReInitPhysicsL(const TSize& aWorldSize,
        const TSize& aViewSize, TBool aLandscape)
    {
    iPhysics->InitPhysicsL(aWorldSize, aViewSize, aLandscape);
    }

//End file