/*

* 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 the License "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 of drag scrolling

*

*/

// INCLUDE FILES

#include <browser_platform_variant.hrh>

#include <../bidi.h>

#include "WebPageScrollHandler.h"

#include "BrCtl.h"

#include "WebFrame.h"

#include "WebFrameView.h"

#include "WebView.h"

#include <AknUtils.h>

#include "Page.h"

#include "Frame.h"

#include "WebCoreFrameBridge.h"

#include "FrameView.h"

#include "FocusController.h"

#include "PlatformScrollbar.h"

#include "WebScrollbarDrawer.h"

#include "RenderObject.h"

#include "WebScrollingDeceleratorGH.h"

#include "pluginskin.h"

#include "WebKitLogger.h"

using namespace WebCore;

// constants

const int KPageOverviewScrollPeriodic = 20 * 1000; // Update frequently for faster, smoother scrolling

const int KMicroInterval = 300000;

const int KPageOverviewScrollStart = 1000;

const int KCancelDecelerationTimeout = 200000; //Decelerate only if flicked KCancelDecelerationTimeout microsec after last drag event.

const int KScrollIntervalTimeout = 40000; // scroll timer interval in microseconds

const int KAngularDeviationThreshold = 160; // % deviation ignored from minor axis of motion(120 means 20 %)

const int KScrollThresholdPixels = 10; // scrolls only if delta is above this threshold

const int KScrollDirectionBoundary = 30; // Bound around focal point within which scrolling locks in X or Y states

const float KTanOfThresholdAngle = 0.46; // tan of 25 degree

int handleScrollTimerEventCallback( TAny* ptr);

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

int WebPageScrollHandler::pageOverviewScrollCallback( TAny* aPtr )

{

#ifdef BRDO_USE_GESTURE_HELPER

    static_cast<WebPageScrollHandler*>(aPtr)->scrollPageOverviewGH();

#else

    static_cast<WebPageScrollHandler*>(aPtr)->handlePageOverviewScrollCallback();

#endif //BRDO_USE_GESTURE_HELPER

    return KErrNone;

}

int handleScrollTimerEventCallback( TAny* ptr)

{

    WebPageScrollHandler* scrollHandler = static_cast<WebPageScrollHandler*>(ptr);

    scrollHandler->scrollContent();

    return EFalse;    

}      

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

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

// ScrollableView::contentPos

// 

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

//

TPoint ScrollableView::contentPos()

{

    WebFrameView* fv = activeFrameView();

    if (fv) return fv->contentPos();

    return TPoint (0,0);

}

WebFrameView* ScrollableView::activeFrameView()

{

    if (m_scrollingElement) {

    }

    else {

        return m_frameView;

    }

}

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

// WebPageScrollHandler::NewL

// The two-phase Symbian constructor

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

//

WebPageScrollHandler* WebPageScrollHandler::NewL(WebView& webView)

    {

    WebPageScrollHandler* self = new (ELeave) WebPageScrollHandler( webView );

    CleanupStack::PushL(self);

    self->constructL();

    CleanupStack::Pop(); //self

    return self;

    }

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

// WebPageScrollHandler::WebPageScrollHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

WebPageScrollHandler::WebPageScrollHandler(WebView& webView)

: m_webView( &webView ), m_decel(0), m_decelGH(NULL)

    {

    }

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

// WebPageScrollHandler::constructL

// The constructor that can contain code that might leave.

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

//

void WebPageScrollHandler::constructL()

    {

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

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

        m_lastPosition = TPoint(0, 0);

        m_scrollbarDrawer = WebScrollbarDrawer::NewL();

        if(AknLayoutUtils::PenEnabled()) {

            m_touchScrolling = true;

            m_scrollDirectionState = ScrollDirectionUnassigned;

#ifndef BRDO_USE_GESTURE_HELPER            

            m_decel = WebScrollingDecelerator::NewL(*m_webView);

#else            

	        m_decelGH = WebScrollingDeceleratorGH::NewL(*m_webView);

#endif	    

        }

        else  {

            m_touchScrolling = false;            

        }

    }

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

// Destructor

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

WebPageScrollHandler::~WebPageScrollHandler()

{    

    if (m_scrollTimer) {

        m_scrollTimer->Cancel();

        delete m_scrollTimer;    

    }

    if (m_pageOverviewScrollPeriodic) {

        m_pageOverviewScrollPeriodic->Cancel();

        delete m_pageOverviewScrollPeriodic;

    }

    delete m_decel;

    delete m_decelGH;

    delete m_scrollbarDrawer;

}

void WebPageScrollHandler::handlePageOverviewScrollingL(const TPointerEvent& pointerEvent)

{

    switch (pointerEvent.iType){

        case TPointerEvent::EButton1Down:            

            m_webView->setViewIsScrolling(false);

            m_lastPointerEvent.iPosition.SetXY(0,0);

            m_lastDragEvent = pointerEvent;

            break;

        case TPointerEvent::EDrag:

            if (!m_webView->viewIsScrolling()){

                m_webView->setViewIsScrolling(true);

                m_pageOverviewScrollPeriodic->Start( 0, KPageOverviewScrollPeriodic, TCallBack(&pageOverviewScrollCallback, this));

            }

            break;

        case TPointerEvent::EButton1Up:

            if (m_pageOverviewScrollPeriodic->IsActive()){ 

                m_pageOverviewScrollPeriodic->Cancel();

            }

            m_webView->closePageView();

            m_webView->setViewIsScrolling(false);

            break;

        default:

            break;

   }

   // Scroll here only for EButton1Up and EButton1Down if needed

   if(pointerEvent.iType != TPointerEvent::EDrag && m_lastPointerEvent.iPosition != pointerEvent.iPosition){

       scrollPageOverview( pointerEvent );

   }

   m_lastPointerEvent = pointerEvent; 

}

void WebPageScrollHandler::handlePageOverviewScrollCallback()

{

    int absX = Abs( m_lastDragEvent.iPosition.iX - m_lastPointerEvent.iPosition.iX);

    int absY = Abs( m_lastDragEvent.iPosition.iY - m_lastPointerEvent.iPosition.iY);

   // Scrolling for EDrag events

    if( absX > 3 ||  absY > 3){

        scrollPageOverview( m_lastPointerEvent );

        m_lastDragEvent = m_lastPointerEvent;

    }

}

void WebPageScrollHandler::scrollPageOverview(const TPointerEvent& pointerEvent)

{

    TRect indicatorRect = m_webView->pageScaler()->IndicatorRect();

    TInt zoomLevel = m_webView->pageScaler()->ZoomOutLevel();

    TPoint currentPosition = m_webView->mainFrame()->frameView()->contentPos();

    TInt xInDoc = ((pointerEvent.iPosition.iX - indicatorRect.iTl.iX  - indicatorRect.Width() / 2) * zoomLevel ) / 100 + currentPosition.iX;

    TInt yInDoc = ((pointerEvent.iPosition.iY - indicatorRect.iTl.iY  - indicatorRect.Height() / 2) * zoomLevel ) / 100 + currentPosition.iY;

    m_webView->mainFrame()->frameView()->scrollTo(TPoint(xInDoc, yInDoc));    

}

void WebPageScrollHandler::updateScrolling(const TPointerEvent& pointerEvent)

{

    switch (pointerEvent.iType)

    {

        case TPointerEvent::EButton1Down:

        {        

            m_lastMoveEventTime = 0; 

            m_lastPosition = pointerEvent.iPosition;

            m_currentPosition = pointerEvent.iPosition;

            m_webView->setViewIsScrolling(false);         

            // stop deceleration scrolling cycle            

            if (m_decel) {

                m_decel->stopDecelL();    

            }

            m_scrollableView.m_scrollingElement = NULL;

            m_scrollableView.m_frameView = NULL;

            break;

        }

        case TPointerEvent::EButton1Up:

        {

            m_scrollTimer->Cancel();

            if (m_scrollableView.m_scrollingElement) {

                clearScrollingElement();

            }

            else {

                if (m_lastMoveEventTime != 0)

                {           

                    // Start deceleration only if the delta since last drag event is less than threshold

                    TTime now;

                    now.HomeTime();             

                    TTimeIntervalMicroSeconds ms = now.MicroSecondsFrom(m_lastMoveEventTime);

                    if (ms < KCancelDecelerationTimeout) {

                        m_decel->startDecelL();    

                    }

                }            

                if (m_webView->viewIsScrolling()) {

                    Frame* frame = m_webView->page()->focusController()->focusedOrMainFrame();

                    frame->bridge()->sendScrollEvent();                            

                }

            }

            m_scrollbarDrawer->fadeScrollbar();

            m_scrollDirectionState = ScrollDirectionUnassigned;

            m_lastMoveEventTime = 0;

            break;

        }

    }

}

void WebPageScrollHandler::setupScrolling(const TPoint& aNewPosition)

{

    if (m_lastPosition == TPoint(0, 0)) {

        m_lastPosition = aNewPosition;

    }

    if(m_lastPosition == aNewPosition)

        return; // no displacement -- means no need for scrolling    

    //Ignore move events until they jump the threshold (avoids jittery finger effect) 

    TInt absX = Abs( aNewPosition.iX - m_lastPosition.iX);

    TInt absY = Abs( aNewPosition.iY - m_lastPosition.iY);

    if( absX < KScrollThresholdPixels &&  absY < KScrollThresholdPixels)

        return;

    if (calculateScrollableFrameView(aNewPosition))  {

        // normalize current position to minimize cumulative rounding error 

        m_currentNormalizedPosition.iX = m_scrollableView.contentPos().iX * 100;

        m_currentNormalizedPosition.iY = m_scrollableView.contentPos().iY * 100;

        // do the scrolling in a time out

        m_scrollTimer->Cancel();                   

        m_scrollTimer->Start( 0, KScrollIntervalTimeout, TCallBack(&handleScrollTimerEventCallback,this));

        m_webView->setViewIsScrolling(true);

        m_webView->toggleRepaintTimer(false);

    }

}

void WebPageScrollHandler::clearScrollingElement()

{

    if (m_scrollableView.m_scrollingElement) {

        m_scrollableView.m_scrollingElement->deref();

        m_scrollableView.m_scrollingElement = NULL;

    }

}

void WebPageScrollHandler::scrollContent()

{

    TPoint scrollDelta = m_lastPosition - m_currentPosition;

    scrollContent(scrollDelta);

}

void WebPageScrollHandler::scrollContent(TPoint& aScrollDelta)

{

    if(!m_scrollableView.activeFrameView())

            return;

    int absX = Abs(aScrollDelta.iX);

    int absY = Abs(aScrollDelta.iY);

    if(absX || absY) //move only if necessary

    {      

        // calculate which direction we are trying to scroll

        if(m_scrollDirectionState == ScrollDirectionUnassigned) {

            m_focalPoint = m_currentPosition;

            calculateScrollDirection(absX, absY);

        }   

        switch (m_scrollDirectionState)

        {           

            case ScrollDirectionX: //scroll in X dir

            {

                aScrollDelta.iY = 0;

                aScrollDelta.iX *= 100;

                //Fallback to XY state if the current position is out of bounds                

                TPoint boundaryCheckpoint = m_focalPoint - m_currentPosition;                                

                if(Abs(boundaryCheckpoint.iY) > KScrollDirectionBoundary)

                    m_scrollDirectionState = ScrollDirectionXY;

                break;

            }

            case ScrollDirectionY: //scroll in Y dir

            {                

                aScrollDelta.iX = 0;

                aScrollDelta.iY *= 100;

                //Fallback to XY state if the current position is out of bounds                

                TPoint boundaryCheckpoint = m_focalPoint - m_currentPosition;                                

                if(Abs(boundaryCheckpoint.iX) > KScrollDirectionBoundary)

                    m_scrollDirectionState = ScrollDirectionXY;

                break;

            }

            case ScrollDirectionXY: //scroll in XY

            {

                aScrollDelta.iX *= 100;

                aScrollDelta.iY *= 100;

                m_scrollDirectionState = ScrollDirectionUnassigned;

                break;

            }

        }        

        if (m_scrollableView.m_scrollingElement) {

            bool shouldScrollVertically = false;

            bool shouldScrollHorizontally = false;

            WebFrame* frame = kit(m_scrollableView.m_scrollingElement->document()->frame());

            RenderObject* render = m_scrollableView.m_scrollingElement->renderer();

            if(render) //check if render exits before using it

                {

                __ASSERT_DEBUG(render->isScrollable(), User::Panic(_L(""), KErrGeneral));

                if (aScrollDelta.iY)

                  shouldScrollVertically = !render->scroll(ScrollDown, ScrollByPixel, frame->frameView()->toDocCoords(aScrollDelta).iY / 100);

                if (aScrollDelta.iX)

                  shouldScrollHorizontally = !render->scroll(ScrollRight, ScrollByPixel, frame->frameView()->toDocCoords(aScrollDelta).iX / 100);

                }

            TPoint scrollPos = frame->frameView()->contentPos();

            TPoint newscrollDelta = frame->frameView()->toDocCoords(aScrollDelta);

            m_currentNormalizedPosition +=  newscrollDelta;     

            if (shouldScrollHorizontally) {

                scrollPos.iX = m_currentNormalizedPosition.iX/100;

            }

            if (shouldScrollVertically) {

                scrollPos.iY = m_currentNormalizedPosition.iY/100;

            }

            if (shouldScrollVertically || shouldScrollHorizontally){

                if (m_scrollableView.m_frameView->needScroll(scrollPos)) {

                    frame->frameView()->scrollTo(scrollPos);

                    updateScrollbars(scrollPos, newscrollDelta);

                    core(frame)->sendScrollEvent();

                }

            }

            else {

                m_webView->syncRepaint();

            }

            m_lastPosition = m_currentPosition;

            m_currentNormalizedPosition.iX = frame->frameView()->contentPos().iX * 100;

            m_currentNormalizedPosition.iY = frame->frameView()->contentPos().iY * 100;

        }

        else {

            TPoint scrollPos;

            TPoint newscrollDelta = m_scrollableView.m_frameView->toDocCoords(aScrollDelta);

            m_currentNormalizedPosition +=  newscrollDelta;  

            scrollPos.iX = m_currentNormalizedPosition.iX/100;

            scrollPos.iY = m_currentNormalizedPosition.iY/100;

            TPoint cpos = m_scrollableView.m_frameView->contentPos();

            if(!m_scrollableView.m_frameView->needScroll(scrollPos)) {

                m_scrollDirectionState = ScrollDirectionUnassigned;

                m_lastPosition = m_currentPosition;

                m_currentNormalizedPosition.iX = m_scrollableView.contentPos().iX * 100;

                m_currentNormalizedPosition.iY = m_scrollableView.contentPos().iY * 100;

            }

            else {

                m_scrollableView.m_frameView->scrollTo(scrollPos);

                m_lastPosition = m_currentPosition;

#ifndef BRDO_USE_GESTURE_HELPER                

                m_decel->updatePos();

#endif                

            // update scroll bars

                updateScrollbars(scrollPos, newscrollDelta);

            }

        }

    }

} 

bool WebPageScrollHandler::calculateScrollableFrameView(const TPoint& aNewPosition)

{

    calculateScrollableElement(aNewPosition);

    //First figure out the direction we are scrolling    

    bool x_r = false;

    bool x_l = false;

    bool y_t = false;

    bool y_b = false;

    //find the x direction

    int x_delta = aNewPosition.iX - m_lastPosition.iX;

    if (x_delta > 0) {

        x_l = true;                

    } else if (x_delta < 0){

        x_r = true;

    }

    //find the y direction

    int y_delta = aNewPosition.iY - m_lastPosition.iY;

    if (y_delta > 0) {

        y_t = true;                

    } else if (y_delta < 0){

        y_b = true;

    }

    m_scrollableView.m_frameView = NULL;

    //find the frame that can scroll if we can't scroll check the parents        

    WebFrame* frame = m_webView->mainFrame()->frameAtPoint(aNewPosition);

    for (; frame; frame = frame->parentFrame())  {

        // Dont scroll a frameset

        if (frame->parentFrame() && frame->parentFrame()->isFrameSet()) 

            continue;     

        TPoint contentpos = frame->frameView()->contentPos();

        TSize contentsize = frame->frameView()->contentSize();        

        TRect framerect = frame->frameView()->rect();        

        //if the content width is > frameview width

        if (contentsize.iWidth > framerect.Width() && frame->frameView()->hScrollbar()->isEnabled()) {

            //IF we are trying to scroll to the right we need 

            //to see if the content position < content size - frameview size        

            //ELSE if we are trying to the left we need 

            //to see if the content position > 0 

            if (x_r) {        

                if (contentpos.iX < (contentsize.iWidth - framerect.Width())) {

                    m_scrollableView.m_frameView = frame->frameView();

                    return true;                

                }

            } else if (x_l) {

                if (contentpos.iX > 0) {

                    m_scrollableView.m_frameView = frame->frameView();

                    return true;                

                }            

            }

        }

        //if the content height is > frameview height

        if (contentsize.iHeight > framerect.Height() && frame->frameView()->vScrollbar()->isEnabled()) {

            //IF we are trying to scroll down we need 

            //to see if the content position < content size - frameview size        

            //ELSE if we are trying to scroll up we need 

            //to see if the content position > 0 

            if (y_b) {        

                if (contentpos.iY < (contentsize.iHeight - framerect.Height())) {

                    m_scrollableView.m_frameView = frame->frameView();

                    return true;                

                }

            } else if (y_t) {

                if (contentpos.iY > 0) {

                    m_scrollableView.m_frameView = frame->frameView();

                    return true;                

                }            

            }

        }

    }