/*
* 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:  Restrictor of AknPhysics
*
*/


#include <e32debug.h>

#include "aknphysicsrestrictor.h"
#include "aknphysicsparameterprovider.h"

const TReal KNotRestrictedSegment( 1.0 );
const TInt KEmptySpaceFactor( 100 );

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

// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::NewL
// ---------------------------------------------------------------------------
//
CAknPhysicsRestrictor* CAknPhysicsRestrictor::NewL(
    CAknPhysicsParameterProvider* aProvider )
    {
    CAknPhysicsRestrictor* self = CAknPhysicsRestrictor::NewLC( aProvider );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::NewLC
// ---------------------------------------------------------------------------
//
CAknPhysicsRestrictor* CAknPhysicsRestrictor::NewLC( 
    CAknPhysicsParameterProvider* aProvider )
    {
    CAknPhysicsRestrictor* self = 
        new ( ELeave ) CAknPhysicsRestrictor( aProvider );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::~CAknPhysicsRestrictor
// ---------------------------------------------------------------------------
//
CAknPhysicsRestrictor::~CAknPhysicsRestrictor()
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::UpdatePhysicsEnvironment
// ---------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::UpdatePhysicsEnvironment( const TSize& aWorldSize,
                                                      const TSize& aViewSize,
                                                      const TBool& aLandscape )
    {
    iWorldSize = aWorldSize;
    iViewSize = aViewSize;
    iLandscape = aLandscape;
    CalculateViewLimits();
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::ViewTopPosition()
// -----------------------------------------------------------------------------
//
TInt CAknPhysicsRestrictor::ViewTopPosition() const
    {
    TInt topPosition( 0 );

    if ( iLandscape )
        {
        topPosition = iViewSize.iWidth/2;
        }
    else
        {
        topPosition = iViewSize.iHeight/2;
        }
    return topPosition;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::ViewBottomPosition()
// -----------------------------------------------------------------------------
//
TInt CAknPhysicsRestrictor::ViewBottomPosition() const
    {
    TInt bottomPosition( 0 );

    // If world size smaller than view size, bottom position is same as top
    // position
    if ( iLandscape && iViewSize.iWidth >= iWorldSize.iWidth
        || !iLandscape && iViewSize.iHeight >= iWorldSize.iHeight )
        {
        bottomPosition = ViewTopPosition();        
        }
        
    // Otherwise calculate bottom position according to world size
    else
        {
        if ( iLandscape )
            {
            bottomPosition = iWorldSize.iWidth - iViewSize.iWidth / 2;
            }
        else
            {
            bottomPosition = iWorldSize.iHeight - iViewSize.iHeight / 2;
            }   
        }
    return bottomPosition;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::PositionRevealsEmptySpace()
// -----------------------------------------------------------------------------
//
TBool CAknPhysicsRestrictor::PositionRevealsEmptySpace( TPoint& aPosition )
    {
    TInt startTop( ViewTopPosition() );
    TInt endBottom( ViewBottomPosition() );
    TInt* positionCoordinate;

    if ( iLandscape )
        {
        positionCoordinate = &aPosition.iX;
        }
    else
        {
        positionCoordinate = &aPosition.iY;
        }

    if ( aPosition == TPoint()
        || *positionCoordinate >= startTop && *positionCoordinate <= endBottom )
        {
        return EFalse;
        }
    
    if ( *positionCoordinate < startTop || WorldFitsToView() )
        {
        *positionCoordinate = startTop;
        }
    else
        {
        *positionCoordinate = endBottom;
        }
    return ETrue;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::AllowedViewPosition()
// -----------------------------------------------------------------------------
//
TBool CAknPhysicsRestrictor::AllowedViewPosition( TPoint& aPosition )
    {
    // No restrictions to empty space, view position always allowed
    if ( !iEmptySpaceRestricted )
        {
        return ETrue;
        }
    
    TBool allow( EFalse );

    TInt *coord;
    if ( iLandscape )
        {
        coord = &aPosition.iX;
        }
    else
        {
        coord = &aPosition.iY;
        }

    // View position is allowed
    if ( *coord >= iPositionTopLimit && *coord <= iPositionBottomLimit )
        {
        allow = ETrue;
        iViewReachedLimit = EFalse;
        }

    // View has reached the limit for the first time - adjust the position
    // exactly to limit position
    else if ( !iViewReachedLimit )
        {
        allow = ETrue;
        iViewReachedLimit = ETrue;
        if ( *coord < iPositionTopLimit )
            {
            *coord = iPositionTopLimit;
            }
        else
            {
            *coord = iPositionBottomLimit;
            }
        }

    // Else view has already reached the limit, view position is not allowed
    // and no need to notify physics observer

    return allow;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::AdjustDragPoint()
// -----------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::AdjustDragPoint( TPoint& aDragPoint )
    {
    if ( iViewReachedLimit )
        {
        iViewReachedLimit = EFalse;

        TInt *coord;
        if ( iLandscape )
            {
            coord = &aDragPoint.iX;
            }
        else
            {
            coord = &aDragPoint.iY;
            }

        if ( *coord < 0 )
            {
            *coord = -iEmptySpaceArea;
            }
        else
            {
            *coord = iEmptySpaceArea;
            }
        }
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::WorldSize()
// -----------------------------------------------------------------------------
//
TSize CAknPhysicsRestrictor::WorldSize() const
    {
    return iWorldSize;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::WorldSize()
// -----------------------------------------------------------------------------
//
TBool CAknPhysicsRestrictor::WorldInLandscape() const
    {
    return iLandscape;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::ParameterProvider()
// -----------------------------------------------------------------------------
//
CAknPhysicsParameterProvider* CAknPhysicsRestrictor::ParameterProvider() const
    {
    return iProvider;
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::PositionToViewTop()
// -----------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::PositionToViewTop( TPoint& aPosition ) const
    {
    TInt topPos( ViewTopPosition() );
    if ( iLandscape )
        {
        aPosition.iX = topPos;
        }
    else
        {
        aPosition.iY = topPos;
        }
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::PositionToViewBottom()
// -----------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::PositionToViewBottom( TPoint& aPosition ) const
    {
    TInt bottomPos( ViewBottomPosition() );

    if ( iLandscape )
        {
        aPosition.iX = bottomPos;
        }
    else
        {
        aPosition.iY = bottomPos;
        }
    }


// -----------------------------------------------------------------------------
// CAknPhysicsRestrictor::PositionIsOutOfBoundaries()
// -----------------------------------------------------------------------------
//
TBool CAknPhysicsRestrictor::PositionIsOutOfBoundaries( 
    const TPoint& aPosition, const TBool& aTopCollision ) const
    {
    TInt startTop( ViewTopPosition() );
    TInt endBottom( ViewBottomPosition() );
    TInt positionCoordinate;

    if ( iLandscape )
        {
        positionCoordinate = aPosition.iX;
        }
    else
        {
        positionCoordinate = aPosition.iY;
        }
        

    if ( aTopCollision && positionCoordinate > startTop )
        {
        positionCoordinate = startTop;
        return ETrue;
        }
    else if ( !aTopCollision && positionCoordinate < endBottom )
        {
        positionCoordinate = endBottom;
        return ETrue;
        }
    return EFalse;
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::CAknPhysicsRestrictor
// ---------------------------------------------------------------------------
//
CAknPhysicsRestrictor::CAknPhysicsRestrictor(
    CAknPhysicsParameterProvider* aProvider )
    : 
    iWorldSize( 0, 0 ),
    iViewSize( 0, 0 ),
    iLandscape( EFalse ),
    iPositionTopLimit( 0 ),
    iPositionBottomLimit( 0 ),
    iEmptySpaceArea( 0 ),
    iProvider( aProvider ),
    iViewReachedLimit( EFalse ),
    iEmptySpaceRestricted( EFalse )
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::ConstructL
// ---------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::ConstructL()
    {
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::CalculateViewLimits
// ---------------------------------------------------------------------------
//
void CAknPhysicsRestrictor::CalculateViewLimits()
    {
    if ( !iProvider )
        {
        return;
        }
        
    TInt viewHeight( iViewSize.iHeight );
    TInt worldHeight( iWorldSize.iHeight );
    TReal emptySegment( KNotRestrictedSegment );

    if ( iLandscape )
        {
        viewHeight = iViewSize.iWidth;
        worldHeight = iWorldSize.iWidth;
        }
        
    // Calculate bottom limit
    if ( viewHeight > worldHeight )
        {
        emptySegment = 
        	( TReal ) iProvider->ShortListEmptySpace() / KEmptySpaceFactor;
        iEmptySpaceArea = 
            worldHeight * ( emptySegment );
        iPositionBottomLimit = viewHeight / 2 + iEmptySpaceArea;
        }
    else
        {
        emptySegment = 
        	( TReal ) iProvider->LongListEmptySpace() / KEmptySpaceFactor;
        iEmptySpaceArea = 
            viewHeight * ( emptySegment );
        iPositionBottomLimit = worldHeight - viewHeight / 2 + iEmptySpaceArea;
        }

    // Calculate top limit
    iPositionTopLimit = viewHeight / 2 - iEmptySpaceArea;
    
    // Check if empty space is really restricted
    if ( emptySegment == KNotRestrictedSegment )
        {
        iEmptySpaceRestricted = EFalse;
        }
    else
        {
        iEmptySpaceRestricted = ETrue;
        }
    }


// ---------------------------------------------------------------------------
// CAknPhysicsRestrictor::WorldFitsToView
// ---------------------------------------------------------------------------
//
TBool CAknPhysicsRestrictor::WorldFitsToView()
    {
    if ( iLandscape && iWorldSize.iWidth < iViewSize.iWidth )
        {
        return ETrue;
        }
    else if ( !iLandscape && iWorldSize.iHeight < iViewSize.iHeight )
        {
        return ETrue;
        }
    return EFalse;
    }