/*
* Copyright (c) 2008 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:
*
*/

//  System includes
#include <e32base.h>
#include <e32const.h>
#include <coecntrl.h>
#include <coemain.h>
#include <aknphysics.h>

// User includes
#include "xncontroladapter.h"
#include "xnuiengine.h"
#include "xnnode.h"
#include "xnnodepluginif.h"
#include "xnproperty.h"

#include "xnscrollablecontroladapter.h"

// Constants
const TInt KOffset( 25 );

_LIT8(KViewportHeight, "viewport-height");
_LIT8(KViewportWidth, "viewport-width");
_LIT8(KViewportTop, "viewport-top");
_LIT8(KViewportLeft, "viewport-left");
_LIT8(KScrollDirection, "scroll-direction");                         
_LIT8(KHorizontal, "horizontal");

const TInt EVertical( 0 );
const TInt EHorizontal( 1 );

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

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::NewL
// Two-phased constructor. Can leave.
// -----------------------------------------------------------------------------
//
CXnScrollableControlAdapter* CXnScrollableControlAdapter::NewL( 
    CXnNodePluginIf& aNode )
    {
    CXnScrollableControlAdapter* self = 
        new ( ELeave ) CXnScrollableControlAdapter( aNode );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::~CXnScrollableControlAdapter
// Destructor.
// -----------------------------------------------------------------------------
//
CXnScrollableControlAdapter::~CXnScrollableControlAdapter()
    {
    delete iPhysics;
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::CXnScrollableControlAdapter
// C++ default constructor. Must not leave.
// -----------------------------------------------------------------------------
//
CXnScrollableControlAdapter::CXnScrollableControlAdapter( CXnNodePluginIf& aNode )
    : iNode( aNode ), iStartPosition( 0, 0), iPreviousPosition( 0, 0 ), 
    iCurrentPosition( 0, 0 ), iLayoutChanged( EFalse )
    {
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::ConstructL
// 2nd phase constructor. Can leave.
// -----------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::ConstructL()
    {
    CXnControlAdapter::ConstructL( iNode );
    SetControlContext( this );
    SetHitTest( this );
    iUiEngine = iNode.Node().UiEngine();
    
    iNode.Node().SetScrollableControl( this );
    
    // Default
    iDirection = EVertical;
    
    CXnProperty* prop( iNode.GetPropertyL( KScrollDirection ) );
    
    if ( prop && prop->StringValue() == KHorizontal )
        {
        iDirection = EHorizontal;
        }    
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::HandlePointerEventL
// 
// -----------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::HandlePointerEventL( 
    const TPointerEvent& aPointerEvent )
    {
    if( !iPhysics )
        {
        return;
        }
    
    TPoint stylusPos( aPointerEvent.iPosition );
    
    switch( aPointerEvent.iType )
        {
        case TPointerEvent::EButton1Down:
            {
            iPhysics->StopPhysics();
            iPhysics->ResetFriction();
            iStartPosition = stylusPos;
            iStartTime.HomeTime();
            iPreviousPosition = iCurrentPosition;
            iStylusPosition = stylusPos;
            }
            break;            
        case TPointerEvent::EButton1Up:
            {                                                        
            TInt distanceY( iStartPosition.iY - stylusPos.iY );                                              
            TInt distanceX( iStartPosition.iX - stylusPos.iX );
            
            TPoint drag( distanceX, distanceY );
            iPhysics->StartPhysics( drag, iStartTime );                                
            }
            break; 
        case TPointerEvent::EDrag:        
            {
            TPoint distanceFromStart( iStartPosition - stylusPos );

            if( ( Abs( distanceFromStart.iY ) > KOffset && iDirection == EVertical ) || 
                ( Abs( distanceFromStart.iX ) > KOffset && iDirection == EHorizontal ) )                 
                {
                CXnNode* focused( iUiEngine->FocusedNode() );
                
                if ( focused )
                    {
                    // Remove pressed down
                    focused->UnsetStateL( 
                        XnPropertyNames::style::common::KFocus );                                                   
                    }
                }
            
            TInt deltaY( iStylusPosition.iY - stylusPos.iY );
            TInt deltaX( iStylusPosition.iX - stylusPos.iX );
            
            iStylusPosition = stylusPos;
            
            TPoint deltaPoint( deltaX, deltaY );
            
            iPhysics->RegisterPanningPosition( deltaPoint );
            }
            break;
        default:                
            break;                
        }
 
    CXnControlAdapter::HandlePointerEventL( aPointerEvent );
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::Draw
// 
// -----------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::Draw( const TRect& aRect ) const
    {
    CXnControlAdapter::Draw( aRect );           
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::SizeChanged
// 
// -----------------------------------------------------------------------------
void CXnScrollableControlAdapter::SizeChanged()
    {
    TRAP_IGNORE(         
        ReadPropertiesL();
        InitPhysicEngineL(); ); 
        
    CXnControlAdapter::SizeChanged();
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::MakeVisible
// 
// -----------------------------------------------------------------------------
// 
void CXnScrollableControlAdapter::MakeVisible( TBool aVisible )
    {
    TBool visible( IsVisible() ? ETrue : EFalse );
    
    if ( visible == aVisible )
        {
        return;
        }
    
    if( aVisible )
        {
        TRAP_IGNORE( InitPhysicEngineL() );
        }
    
    CCoeControl::MakeVisible( aVisible );            
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::HitRegionContains
// 
// -----------------------------------------------------------------------------
// 
TBool CXnScrollableControlAdapter::HitRegionContains( const TPoint& aPoint, 
    const CCoeControl& /*aControl*/) const
    {
    return iViewPort.Contains( aPoint );
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::HandleScreenDeviceChangedL
// 
// -----------------------------------------------------------------------------
void CXnScrollableControlAdapter::HandleScreenDeviceChangedL()
    {
    // The new layout has not been calculated yet. 
    // Therefore we need to read new propertues and initialise engine when LayoutChagedL() is called next time.
    iLayoutChanged = ETrue;
    CXnControlAdapter::HandleScreenDeviceChangedL();
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::DeltaPosition
// 
// -----------------------------------------------------------------------------
const TPoint CXnScrollableControlAdapter::DeltaPosition() const
    {
    return iStartViewPosition - iCurrentPosition;
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::ResetState
// 
// -----------------------------------------------------------------------------
void CXnScrollableControlAdapter::ResetState()
    {
    iStartViewPosition = TPoint( 0, 0 );
    iCurrentPosition = TPoint( 0, 0 );
    iPreviousPosition = TPoint( 0, 0 );
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::ShowItem
// 
// -----------------------------------------------------------------------------
void CXnScrollableControlAdapter::ShowItem( CXnNode& aNode )
    {
    TRect rect( aNode.MarginRect() );
    
    if ( !iViewPort.Contains( rect.iTl ) || !iViewPort.Contains( rect.iBr ) )
        {
        if ( iDirection == EVertical )
            {                            
            TInt delta( 0 );

            if ( rect.iTl.iY < iViewPort.iTl.iY )
                {
                delta = rect.iTl.iY - iViewPort.iTl.iY;
                }
            else if ( rect.iBr.iY > iViewPort.iBr.iY )
                {
                delta = rect.iBr.iY - iViewPort.iBr.iY;
                }
            
            if ( delta != 0 )
                {
                TPoint newPosition( iPreviousPosition + TPoint( 0, delta ) );
                
                ViewPositionChanged( newPosition, ETrue, 0 );            
                }
            }
        else
            {
            TInt delta( 0 );
            
            if ( rect.iTl.iX < iViewPort.iTl.iX )
                {
                delta = rect.iTl.iX - iViewPort.iTl.iX;
                }
            else if ( rect.iBr.iX > iViewPort.iBr.iX )
                {
                delta = rect.iBr.iX - iViewPort.iBr.iX;
                }
            
            if ( delta != 0 )
                {
                TPoint newPosition( iPreviousPosition + TPoint( delta, 0 ) );
                
                ViewPositionChanged( newPosition, ETrue, 0 );                        
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// CXnScrollableControlAdapter::LayoutChangedL
// 
// -----------------------------------------------------------------------------
void CXnScrollableControlAdapter::LayoutChangedL()
    {
    if( iLayoutChanged )
        {
        iLayoutChanged = EFalse;
        ReadPropertiesL();
        InitPhysicEngineL();
        }
    }

// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::ViewPositionChanged
// ---------------------------------------------------------------------------
//
void CXnScrollableControlAdapter::ViewPositionChanged( 
    const TPoint& aNewPosition, TBool aDrawNow, TUint /*aFlags*/ )
    {
    TPoint diff;
    
    if ( iDirection == EVertical )
        {
        diff = TPoint( 0, aNewPosition.iY - iPreviousPosition.iY );
        }
    else
        {
        diff = TPoint( aNewPosition.iX - iPreviousPosition.iX, 0 );
        }
    
    iPreviousPosition = aNewPosition;
    iCurrentPosition += diff;
    TPoint tmpPos = iNode.Control()->Position();
    tmpPos -= diff;
    iNode.Control()->SetPosition( tmpPos );
    if( aDrawNow )
        {
        DrawNow( iViewPort );    
        }
    }
    
// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::PhysicEmulationEnded
// ---------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::PhysicEmulationEnded()
    {
    }

// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::ViewPosition
// ---------------------------------------------------------------------------
//    
TPoint CXnScrollableControlAdapter::ViewPosition() const
    {
    return iCurrentPosition;
    }

// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::ResetContext
// ---------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::ResetContext( CWindowGc& aGc ) const
    {
    aGc.Reset();
    aGc.SetClippingRect( iViewPort );
    }

// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::InitPhysicEngineL
// ---------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::InitPhysicEngineL()
    {
    // Init physic engine
    if ( !iPhysics && CAknPhysics::FeatureEnabled() )
        {
        iPhysics = CAknPhysics::NewL( *this, this );
        }
    if( !iPhysics )
        {
        return;
        }
    TSize viewPortSize = iViewPort.Size();
    TSize totalSize( iNode.Rect().Size() );
    
    if ( iDirection == EVertical )
        {
        iPhysics->InitPhysicsL( totalSize, viewPortSize, EFalse );
        }
    else
        {
        iPhysics->InitPhysicsL( totalSize, viewPortSize, ETrue );
        }
    
    
    iCurrentPosition = 
        TPoint( viewPortSize.iWidth / 2, viewPortSize.iHeight / 2 ); 
                  
    iPreviousPosition = iStartViewPosition =  iCurrentPosition;
    }

// ---------------------------------------------------------------------------
// CXnScrollableControlAdapter::ReadPropertiesL
// ---------------------------------------------------------------------------
//    
void CXnScrollableControlAdapter::ReadPropertiesL()
    {
    TInt width( 0 );
    TInt height( 0 );
    TInt top( 0 );
    TInt left( 0 );

    CXnNode& node( iNode.Node() );
    
    // Width
    CXnProperty* prop = iNode.GetPropertyL( KViewportWidth );
    if( prop )
        {
        width = iUiEngine->HorizontalPixelValueL(
            prop, iNode.Rect().Width() );
        }
    if( width == 0 )
        {
        width = node.Parent()->Rect().Width();
        }

    // Height
    prop = iNode.GetPropertyL( KViewportHeight );
    if( prop )
        {
        height = iUiEngine->VerticalPixelValueL(
            prop, iNode.Rect().Height() );
        }
    if( height == 0 )
        {
        height = node.Parent()->Rect().Height();
        }

    // Top
    prop = iNode.GetPropertyL( KViewportTop );
    if( prop )
        {
        top = iUiEngine->VerticalPixelValueL(
            prop, iNode.Rect().Height() );
        }

    // Left
    prop = iNode.GetPropertyL( KViewportLeft );
    if( prop )
        {
        left = iUiEngine->HorizontalPixelValueL(
            prop, iNode.Rect().Width() );
        }

    iViewPort = TRect( iNode.Rect().iTl, TSize( width, height ) );
    iViewPort.Move( left, top );
    }

//  End of File