/*

 * Copyright (c) 2002-2004 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:  Implementation for wrapper for a box

 *

 */

// System includes

#include <akntouchgesturefwevents.h>

#include <centralrepository.h>

#include <activeidle2domaincrkeys.h>

#include <gfxtranseffect/gfxtranseffect.h>  

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

// User includes

#include "xnappuiadapter.h"

#include "xnuiengine.h"

#include "xnproperty.h"

#include "xnviewmanager.h"

#include "xnviewdata.h"

#include "xndomnode.h"

#include "xnnode.h"

#include "xnviewcontroladapter.h"

#include "xneffectmanager.h"

#include "xnrootdata.h"

#include "xnviewadapter.h"

#include "xnbackgroundmanager.h"

#include "xnviewswitcher.h"

// Constants

const TInt KDrawDelay( 25000 ); // 16100 = 62 fps

const TInt KDragTreshold( 30 );

const TInt KMaxScrollSpeed( 150 );

const TInt KMinScrollSpeed( 20 );

const TInt KAnimationDuration( 500000 );

const TInt KDragOffsetForBackground( 100 );

const TInt KDragOffsetForPageSwitch( 50 );

enum TViewPosition

    {

    KCurrentView, KNextView, KPreviousView

    };

// ============================= LOCAL FUNCTIONS ===============================

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

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

//

void HideAdapter( CXnControlAdapter* aAdapter )

    {

    if( aAdapter )

        {

        aAdapter->Window().SetOrdinalPosition( -1 );

        }    

    }

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

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

//

void ShowAdapter( CXnControlAdapter* aAdapter )

    {

    if( aAdapter )

        {

        aAdapter->Window().SetOrdinalPosition( 1 );

        }    

    }

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

// Changes window position

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

//

void SetWindowPosition( CXnControlAdapter* aAdapter, const TPoint& aPos )

    {

    if( aAdapter )

        {

        aAdapter->Window().SetPosition( aPos );

        }

    }

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

// Hide/Show control

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

//

void SetVisible( CCoeControl* aControl, TBool aVisible )

    {

    if( aControl )

        {

        aControl->MakeVisible( aVisible );

        }

    }

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

// ShowNodes

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

//

void ShowNodesL( CXnNode& aNode, TBool aShow )

    {    

    CXnDomStringPool* sp( aNode.DomNode()->StringPool() );

    CXnProperty* prop( NULL );

    if( aShow )

        {

        prop = CXnProperty::NewL(

            XnPropertyNames::style::common::KDisplay, 

            XnPropertyNames::style::common::display::KBlock,

            CXnDomPropertyValue::EString, *sp );    

        } 

    else

        {

        prop = CXnProperty::NewL(

            XnPropertyNames::style::common::KDisplay, 

            XnPropertyNames::style::common::display::KNone,

            CXnDomPropertyValue::EString, *sp );

        }

    CleanupStack::PushL( prop );    

    aNode.SetPropertyWithoutNotificationL( prop );

    CleanupStack::Pop( prop );

    }

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

// IsNodeVisible

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

//

TBool IsNodeVisibleL( CXnNode& aNode )

    {

    CXnProperty* displayProp( aNode.DisplayL() );

    if ( displayProp )

        {

        const TDesC8& display( displayProp->StringValue() );

        if ( display == XnPropertyNames::style::common::display::KBlock )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

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

// CXnViewSwitcher::NewL

// Symbian static 1st phase constructor

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

//

CXnViewSwitcher* CXnViewSwitcher::NewL()

    {

    CXnViewSwitcher* self = new (ELeave) CXnViewSwitcher();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CXnViewSwitcher::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnViewSwitcher::ConstructL()

    {

    iFingerFollowSupported = IsFingerFollowSupportedL();

    iTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

    iViewSwitchState = KViewSwitchIdle;

    }

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

// CXnViewSwitcher::CXnViewSwitcher

// C++ default constructor

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

//

CXnViewSwitcher::CXnViewSwitcher() :

    iAppUi(static_cast<CXnAppUiAdapter&> (*iAvkonAppUi))

    {

    }

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

// CXnViewSwitcher::~CXnViewSwitcher

// C++ destructor

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

//

CXnViewSwitcher::~CXnViewSwitcher()

    {    

    if (iTimer->IsActive())

        {

        iTimer->Cancel();

        }

    delete iTimer;

    }

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

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

//

TBool CXnViewSwitcher::FingerFollowSupported() const

    {

    return iFingerFollowSupported;

    }

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

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

//

TBool CXnViewSwitcher::ProcessPointerEventL(const TPointerEvent& aPointerEvent )

    {

    TBool consumed(EFalse);

    if ( FingerFollowSupported() )

        {

        TPoint parentPos = aPointerEvent.iParentPosition;

        switch (aPointerEvent.iType)

            {

            case TPointerEvent::EButton1Down:

                {

                if ( iViewSwitchState == KViewSwitchBegin || iViewSwitchState

                        == KViewSwitchIdle )

                    {

                    if (iTimer->IsActive())

                        {

                        iTimer->Cancel();

                        }

                    if( SetupViewsL() )

                        {

                        iViewSwitchState = KViewSwitchBegin;

                        iStartPosition = parentPos;

                        iScrollSpeed = KMaxScrollSpeed;

                        iTickAmount = 0;

                        iDirection = KCurrentView;

                        iScrollDistance = 0;

                        iScrollDirectionDistance = 0;

                        }

                    }

                else if( iViewSwitchState == KViewSwitchDragOngoing )

                    {

                    consumed = ETrue;

                    }

                else if( iViewSwitchState == KViewSwitchScroll )

                    {

                    consumed = ETrue;

                    if( iActivateView == KCurrentView )

                        {

                        if (iTimer->IsActive())

                            {

                            iTimer->Cancel();

                            }                    

                        iViewSwitchState = KViewSwitchDragOngoing;

                        consumed = ETrue;    

                        iViewStartPosition = iViewPosition;

                        iScrollDistance = 0;

                        iScrollDirectionDistance = 0;

                        iStartPosition = parentPos;

                        iTimer->Start( 0, KDrawDelay, TCallBack(

                                TimerCallback, this ) );

                        }

                    else if( iActivateView == KNextView )

                        {

                        if( iCurrentView.iAdapter && iNextView.iAdapter && 

                            iPreviousView.iAdapter )

                            {

                            if (iTimer->IsActive())

                                {

                                iTimer->Cancel();

                                }

                            iViewSwitchState = KViewSwitchDragOngoing;

                            iActivateView = KCurrentView;

                            if( iPreviousView.iAdapter == iNextView.iAdapter )

                                {

                                iPreviousView = iCurrentView;

                                iCurrentView = iNextView;

                                iNextView = iPreviousView;

                                }

                            else

                                {

                                iPreviousView = iCurrentView;

                                iCurrentView = iNextView;

                                iNextView.iReadyToDraw = EFalse;

                                CXnViewData* nextViewData( 

                                    ViewData( *iCurrentView.iViewData, KNextView ) );

                                CXnNode* nextViewNode( nextViewData->ViewNode() );

                                if( nextViewNode )

                                    {

                                    iNextView.iAdapter = nextViewNode->Control();

                                    iNextView.iViewData = nextViewData;

                                    iNextView.iBgDrawn = EFalse;

                                    }                            

                                }

                            iViewStartPosition = iCurrentView.iAdapter->Window().Position();

                            iScrollDistance = 0;

                            iScrollDirectionDistance = 0;

                            iStartPosition = parentPos;

                            iScrollSpeed = KMaxScrollSpeed;

                            iTickAmount = 0;

                            iTimer->Start( 0, KDrawDelay, TCallBack(

                                    TimerCallback, this ) );

                            }

                        consumed = ETrue;

                        }

                    else if( iActivateView == KPreviousView )

                        {

                        if( iCurrentView.iAdapter && iNextView.iAdapter && 

                            iPreviousView.iAdapter )

                            {

                            if (iTimer->IsActive())

                                {

                                iTimer->Cancel();

                                }

                            iViewSwitchState = KViewSwitchDragOngoing;

                            iActivateView = KCurrentView;

                            if( iPreviousView.iAdapter == iNextView.iAdapter )

                                {

                                iNextView = iCurrentView;

                                iCurrentView = iPreviousView;

                                iPreviousView = iNextView;

                                }

                            else

                                {

                                iNextView = iCurrentView;

                                iCurrentView = iPreviousView;

                                iPreviousView.iReadyToDraw = EFalse;

                                CXnViewData* prevViewData( 

                                    ViewData( *iCurrentView.iViewData, KPreviousView ) );

                                CXnNode* prevViewNode( prevViewData->ViewNode() );

                                if( prevViewNode )

                                    {

                                    iPreviousView.iAdapter = prevViewNode->Control();

                                    iPreviousView.iViewData = prevViewData;

                                    iPreviousView.iBgDrawn = EFalse;

                                    }                            

                                }

                            iViewStartPosition = iCurrentView.iAdapter->Window().Position();

                            iScrollDistance = 0;

                            iScrollDirectionDistance = 0;

                            iStartPosition = parentPos;

                            iScrollSpeed = KMaxScrollSpeed;

                            iTickAmount = 0;

                            iTimer->Start( 0, KDrawDelay, TCallBack(

                                TimerCallback, this ) );

                            }

                        consumed = ETrue;

                        }

                    }

                }

                break;

            case TPointerEvent::EDrag:

                {

                if( iViewSwitchState == KViewSwitchIdle )

                    {

                    consumed = EFalse;

                    }

                else if( iViewSwitchState == KViewSwitchBegin )

                    {

                    TPoint delta = parentPos - iStartPosition;

                    if( Abs(delta.iX) > KDragTreshold || Abs(delta.iY) > KDragTreshold )

                        {

#ifdef RD_TACTILE_FEEDBACK            

                        MTouchFeedback* feedback( MTouchFeedback::Instance() );

                        if ( feedback )

                            {

                            feedback->InstantFeedback( ETouchFeedbackBasic );

                            }

#endif                           

                        iViewSwitchState = KViewSwitchDragOngoing;

                        iActivateView = KCurrentView;

                        iViewPosition.iY = iCurrentView.iAdapter->Position().iY;

                        iViewPosition.iX = 0;

                        iStartPosition = parentPos;

                        StartViewDraggingL();

                        iTimer->Start( 0, KDrawDelay, TCallBack(

                                TimerCallback, this ) );

                        }

                    consumed = ETrue;

                    }

                else if( iViewSwitchState == KViewSwitchDragOngoing )

                    {

                    iScrollDistance = parentPos.iX - iStartPosition.iX;

                    consumed = ETrue;

                    }

                else

                    {

                    consumed = EFalse;                

                    }

                }

                break;

            case TPointerEvent::EButton1Up:

                {

                if( iViewSwitchState == KViewSwitchBegin )

                    {

                    iViewSwitchState = KViewSwitchIdle;

                    }

                else if( iViewSwitchState == KViewSwitchDragOngoing )

                    {

                    if (iTimer->IsActive())

                        {

                        iTimer->Cancel();

                        }                    

#ifdef RD_TACTILE_FEEDBACK            

/*

                    MTouchFeedback* feedback( MTouchFeedback::Instance() );

                    if ( feedback )

                        {

                        feedback->InstantFeedback( ETouchFeedbackBasic );

                        }

*/

#endif                           

                    consumed = ETrue;

                    StartViewScrolling();

                    iViewSwitchState = KViewSwitchScroll;

                    }

                else if( iViewSwitchState == KViewSwitchScroll )

                    {

                    consumed = ETrue;

                    }

                }

                break;

            default:

                break;

            }

        }

    return consumed;

    }

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

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

//

void CXnViewSwitcher::TouchGesture( TAknTouchGestureFwType& /*aTouchGesture*/ )

    {

    }

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

// CXnViewSwitcher::SizeChanged

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

// 

void CXnViewSwitcher::SizeChanged( TRect aRect )

    {

    iRect = aRect;

    }

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

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

//

TBool CXnViewSwitcher::SetupViewsL()

    {

    TBool ret = EFalse;

    CXnViewManager& wManager = iAppUi.ViewManager();

    iCurrentView.iViewData = &wManager.ActiveViewData();

    iCurrentView.iAdapter = iCurrentView.iViewData->ViewNode()->Control();

    iCurrentView.iReadyToDraw = ETrue;

    iCurrentView.iBgDrawn = ETrue;

    iViewStartPosition = TPoint( 0, iCurrentView.iAdapter->Window().Position().iY );

    if ( wManager.ViewAmount() > 1 )

        {

        ret = ETrue;

        CXnNode* nextViewNode( wManager.NextViewData().ViewNode() );

        if( nextViewNode )

            {

            iNextView.iAdapter = nextViewNode->Control();

            iNextView.iViewData = &wManager.NextViewData();

            }

        CXnNode* prevViewNode( wManager.PreviousViewData().ViewNode() );

        if( prevViewNode && prevViewNode == nextViewNode )

            {

            // Only 2 views in Homesceern -> previous = next

            iPreviousView = iNextView;

            }

        else if( prevViewNode )

            {

            iPreviousView.iAdapter = prevViewNode->Control();

            iPreviousView.iViewData = &wManager.PreviousViewData();

            }

        }

    return ret;

    }

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

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

//

void CXnViewSwitcher::PrepareViewL( CXnViewSwitcher::TViewInformation& aView )

    {

    if( !aView.iAdapter || !aView.iViewData )

        {

        return;