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

#include <Browser_platform_variant.hrh>
#include "config.h"
#include "../../bidi.h"
#include <AknUtils.h>
#ifdef BRDO_TOUCH_ENABLED_FF
#include <touchfeedback.h>
#endif // BRDO_TOUCH_ENABLED_FF
#include "brctl.h"
#include "BrCtlDefs.h"
#include "WebPointerEventHandler.h"
#include "WebView.h"
#include "WebFrame.h"
#include "WebFrameView.h"
#include "WebCursor.h"
#include "WebPopupDrawer.h"
#include "WebFormFillPopup.h"
#include "WebPageScrollHandler.h"
#include "WebFepTextEditor.h"
#include "WebCoreFrameBridge.h"
#include "StaticObjectsContainer.h"
#include "PluginSkin.h"
#include "WebUtil.h"
#include "Element.h"
#include "Document.h"
#include "Frame.h"
#include "FrameView.h"
#include "EventHandler.h"
#include "EventNames.h"
#include "HitTestResult.h"
#include "MouseEvent.h"
#include "WebPageFullScreenHandler.h"
#include "PluginSkin.h"
#include "PluginWin.h"
#include "WebFrameBridge.h"
#include "Page.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "FocusController.h"
#include "WebTabbedNavigation.h"
#include "PluginHandler.h"

#include "WebKitLogger.h"
using namespace WebCore;
using namespace EventNames;
using namespace RT_GestureHelper;

static const int KMinScrollAndTapInterval = 200000;				// 200 ms
static const int KDoubleTapMinActivationInterval = 100000;     // 100 ms
static const int KDoubleTapMaxActivationInterval = 500000;     // 500 ms
static const int KDoubleTapIdleInterval = 700000;			// 700 ms, to prevent triple-tap effects

//-----------------------------------------------------------------------------
// WebPointerEventHandler::NewL
//-----------------------------------------------------------------------------
WebPointerEventHandler* WebPointerEventHandler::NewL(WebView* view)
{
    WebPointerEventHandler* self = new (ELeave) WebPointerEventHandler(view);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
}

//-----------------------------------------------------------------------------
// WebPointerEventHandler::WebPointerEventHandler
//-----------------------------------------------------------------------------
WebPointerEventHandler::WebPointerEventHandler(WebView* view)
    : m_webview(view),
      m_isHighlighted(false),
      m_highlightedNode(NULL),
      m_buttonDownTimer( this, &WebPointerEventHandler::buttonDownTimerCB ),
      m_ignoreTap(false)
{
}

//-----------------------------------------------------------------------------
// WebPointerEventHandler::~WebPointerEventHandler
//-----------------------------------------------------------------------------
WebPointerEventHandler::~WebPointerEventHandler()
{
    delete m_gestureHelper;
    delete m_waiter;
}

//-----------------------------------------------------------------------------
// WebPointerEventHandler::ConstructL
//-----------------------------------------------------------------------------
void WebPointerEventHandler::ConstructL()
{
#ifdef BRDO_USE_GESTURE_HELPER  
  m_gestureHelper = CGestureHelper::NewL( *this );
  m_gestureHelper->SetDoubleTapEnabled(true);
  m_gestureHelper->SetHoldingEnabled(false);
#else
  m_gestureHelper = NULL;
#endif  
  m_waiter = new(ELeave) CActiveSchedulerWait();
}
/**
 * EGestureStart is sent on touch down
 * EGestureReleased is sent on touch up
 * EGestureTap = touch down + touch up - events sent: EGestureStart, EGestureTap
 *                EGestureReleased
 * EGestureDrag = touch down + "move" - events sent: EGestureStart, EGestureDrag
 * EGestureDoubleTap = 2 * (touch down + touch up) - events sent EGestureStart, 
 *                     EGestureDoubleTap, EGestureReleased
 * EGestureLongTap = touch down + "long touch" - events sent: EGestureStart, 
 *                   EGestureLongTap
 * EGestureSwipe<Up/Down/Left/Right> - drag + touch up, where movements is
 *                   close to particular direction - event sent: EGestureSwipe, 
 *                   EGestureReleased
 * EGestureFlick - "fast" drag + touch up - events sent: EGestureFlick, 
 *                  EGestureReleased
 * EGestureDrop -  drag + touch up, !(EGestureSwipe || EGestureFlick) - events
 *                 sent: EGestureDrop, EGestureReleased
 */
void WebPointerEventHandler::HandleGestureL( const TGestureEvent& aEvent )
{
    TGestureCode gtype = aEvent.Code(EAxisBoth);
    TPoint gpos = aEvent.CurrentPos();
    
    TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
    
    PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();
    if (plugin && plugin->pluginWin()) {
      if (plugin->pluginWin()->HandleGesture(aEvent)) {
          return;
      }
    }
    updateCursor(aEvent.CurrentPos());

    switch (gtype) {
      // sent on touch down
      case EGestureStart:  
      {
          if (m_webview->viewIsScrolling()) {
              m_ignoreTap = true;
              m_webview->pageScrollHandler()->handleTouchDownGH(aEvent);
          }
          else {
              handleTouchDownL(aEvent);   
          }
          break;
      }
      
      // sent on tap
      case EGestureTap:
      {
          if (!m_ignoreTap) {
              handleTapL(aEvent);
          }
          break;    
      }
      
      // sent on double tap
      case EGestureDoubleTap:
      {
          handleDoubleTap(aEvent);
          break;    
      }
      
      // sent on long tap
      case EGestureLongTap:
      {
          break;    
      }

      // sent on touch up after drag
      case EGestureDrop:
      case EGestureFlick:
      case EGestureSwipeLeft:
      case EGestureSwipeRight:
      case EGestureSwipeUp:
      case EGestureSwipeDown:
      {
          m_ignoreTap = false;
          handleTouchUp(aEvent);      
          break;    
      }
      // sent on move
      case EGestureDrag:
      {
          handleMove(aEvent);
          break;    
      }
      
      // sent on touch up after tap double tap and long tap
      case EGestureReleased:
      {
          m_ignoreTap = false;
          handleTouchUp(aEvent);      
          break;    
      }
    }
}


// ======================================================================
// WebPointerEventHandler::handleTap
// ======================================================================
void WebPointerEventHandler::handleTapL(const TGestureEvent& aEvent)
{
    m_buttonDownTimer.stop();
    m_lastTapEvent = m_currentEvent; 
    if(!m_webview->inPageViewMode()){
    	doTapL();
    }
}
// ======================================================================
//  WebPointerEventHandler::handleDoubleTap
//======================================================================
void WebPointerEventHandler::handleDoubleTap(const TGestureEvent& aEvent)
{
    if ( !m_webview->viewIsScrolling() &&
         (m_webview->brCtl()->capabilities() & TBrCtlDefs::ECapabilityFitToScreen)) {
        if (m_isHighlighted){
            dehighlight();                
        }
        m_webview->setZoomLevelAdaptively();
    }
    else {
        m_webview->resetLastZoomLevelIfNeeded();
    }
}

// ======================================================================
// WebPointerEventHandler::handleTouchDownL
//======================================================================
void WebPointerEventHandler::handleTouchDownL(const TGestureEvent& aEvent)
{
    TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
    PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();
    PluginSkin* pluginToActivate = pluginHandler->pluginToActivate();
    m_buttonDownEvent = m_currentEvent;
    m_highlightPos = aEvent.CurrentPos();
    
    if ( !m_buttonDownTimer.isActive() && !m_webview->inPageViewMode() && 
         !pluginToActivate ){
        m_buttonDownTimer.startOneShot(0.1f);        
    }

    m_webview->pageScrollHandler()->handleTouchDownGH(aEvent);

    if ( TBrCtlDefs::EElementActivatedObjectBox == elType) {
        PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();
        if (plugin && plugin->pluginWin()) {
            if (!plugin->getClipRect().Contains(m_buttonDownEvent.iPosition)) {
                plugin->deActivate();
            }
            else {
                plugin->pluginWin()->HandlePointerEventL(m_buttonDownEvent);
            }
        }
    }
    if (pluginToActivate) {
        Frame* coreFrame = core(m_webview->mainFrame());
        coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(m_buttonDownEvent));
    }    
    /*
     * After introducing "link selection" pointer down action is done in 
     * buttondown timer callback. When "down" gesture event is arrived we start 
     * timer end exit, so gesture helper is ready to deliver next gesture event. 
     * Meanwhile the processing of the first gesture event hasn't been finished yet. 
     * The gesture helper doesn't "know" about our plans to handle the event inside 
     * timer callback and only way for us to "tell" about this is to stop RunL() 
     * of CGestureEventSender (HandleGestureL() is inside it) and finish buttondown 
     * timer callback first.  
     */    
    if ( m_buttonDownTimer.isActive()){
    	m_waiter->Start();	
    }
}

// ======================================================================
// WebPointerEventHandler::handleTouchUp 
// ======================================================================
void WebPointerEventHandler::handleTouchUp(const TGestureEvent& aEvent)
{
    m_highlightPos = TPoint(-1,-1);
    m_highlightedNode = NULL;
       
    m_webview->pageScrollHandler()->handleTouchUpGH(aEvent);
}

// ======================================================================
// WebPointerEventHandler::handleMoveL
// ======================================================================
void WebPointerEventHandler::handleMove(const TGestureEvent& aEvent)
{
    TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
    TPoint curPos = aEvent.CurrentPos();
    
    m_buttonDownTimer.stop();
    HandleHighlightChange(curPos);
    
    if (elType == TBrCtlDefs::EElementActivatedObjectBox) {
        PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();               
        if (plugin) {
            plugin->deActivate();
        }
    }
    
    m_webview->pageScrollHandler()->handleScrollingGH(aEvent);
}


// ======================================================================
// WebPointerEventHandler::HandlePointerEventL
// ======================================================================
void WebPointerEventHandler::HandlePointerEventL(const TPointerEvent& aPointerEvent)
{
    m_currentEvent = aPointerEvent;
    
    if (m_webview->isSynchRequestPending()) { 
       return;
    }
    
    // Handle graphical history - should never happen, as HistoryView handles this event by itself
    if ( m_webview->brCtl()->historyHandler()->historyController()->historyView()) {
        return;
    }

    // Handle FormFill popup
    if (m_webview->formFillPopup() && m_webview->formFillPopup()->IsVisible()) {
        m_webview->formFillPopup()->HandlePointerEventL(aPointerEvent);
        return;
    }
    
    if (!m_webview->inPageViewMode()) {
        if (aPointerEvent.iType == TPointerEvent::EButton1Down) {
            m_webview->GetContainerWindow().EnablePointerMoveBuffer();
        }
        else if (aPointerEvent.iType == TPointerEvent::EButton1Up) {
            m_webview->GetContainerWindow().DisablePointerMoveBuffer();
        }
    }

#ifdef BRDO_USE_GESTURE_HELPER
    m_gestureHelper->HandlePointerEventL(aPointerEvent);
#endif    
}

//-----------------------------------------------------------------------------
// WebPointerEventHandler::HandleHighlightChange
//-----------------------------------------------------------------------------
void WebPointerEventHandler::HandleHighlightChange(const TPoint &aPoint)
{
    if (!m_highlightedNode || !m_isHighlighted)    return;

    if (!canDehighlight(aPoint)) return;

    dehighlight();
}

//-----------------------------------------------------------------------------
// WebPointerEventHandler::checkForEventListener
//-----------------------------------------------------------------------------
bool WebPointerEventHandler::checkForEventListener(WebCore::Node* node)
{
    EventTargetNode* etnfound = NULL;
    for (Node* np = node; np; np = np->parentNode()) {
        //check for a mouseover event listener
        if (np->isEventTargetNode()) {
            if (m_webview->page()->chrome()->client()->elementVisibilityChanged()) {
                return true;
            }
        }
    }
    return false;
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::highlitableElement
//-----------------------------------------------------------------------------
TBrCtlDefs::TBrCtlElementType WebPointerEventHandler::highlitableElement()
{
    TRect elRect;
    TBrCtlDefs::TBrCtlElementType elType = TBrCtlDefs::EElementNone;
    Frame* coreFrame = core(m_webview->mainFrame());
    WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
    m_webview->page()->chrome()->client()->setElementVisibilityChanged(false);
    HitTestResult htresult(cursor->position());
    TPointerEvent event;
    TPoint pos = cursor->position();
    event.iPosition = pos;
    event.iModifiers = 0;
    event.iType = TPointerEvent::EMove;
    coreFrame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event),&htresult);
    WebFrame* frm = cursor->getFrameUnderCursor();
    TPoint pt(frm->frameView()->viewCoordsInFrameCoords(pos));
    TPoint nodePoint;
    
    m_highlightedNode = NULL;

    cursor->navigableNodeUnderCursor(*(frm), pt, elType, elRect);
    if (elType == TBrCtlDefs::EElementNone) {
        
        Node* n = frm->getClosestAnchorElement(cursor->position(), pos);
        if (n) {
            htresult = HitTestResult(pos);
            event.iPosition = pos;
            coreFrame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event),&htresult);
            coreFrame->bridge()->getTypeFromElement(htresult.innerNode(), elType, elRect);
            TPoint nodePoint = n->getRect().Rect().Center();
            m_offset = (pt.iX- nodePoint.iX)*(pt.iX- nodePoint.iX) +
                       (pt.iY- nodePoint.iY)*(pt.iY- nodePoint.iY);
            
            
        }
    }
    m_highlightedNode = htresult.innerNode();
    if (m_highlightedNode) {
        m_highlightPos = pos;
        m_buttonDownEvent.iPosition = m_highlightPos;
    }
    m_webview->setFocusedElementType(elType);
    return elType;
}

// ======================================================================
// WebPointerEventHandler::isHighlitableElement
// ======================================================================
bool WebPointerEventHandler::isHighlitableElement(TBrCtlDefs::TBrCtlElementType& elType)
{
    return (elType == TBrCtlDefs::EElementAnchor
                    || elType == TBrCtlDefs::EElementInputBox
                    || elType == TBrCtlDefs::EElementActivatedInputBox
                    || elType == TBrCtlDefs::EElementButton
                    || elType == TBrCtlDefs::EElementCheckBoxChecked
                    || elType == TBrCtlDefs::EElementCheckBoxUnChecked
                    || elType == TBrCtlDefs::EElementTextAreaBox
                    || elType == TBrCtlDefs::EElementRadioButtonSelected
                    || elType == TBrCtlDefs::EElementRadioButtonUnSelected
                    || elType == TBrCtlDefs::EElementTelAnchor
                    || elType == TBrCtlDefs::EElementMailtoAnchor
                    || elType == TBrCtlDefs::EElementSmartLinkTel
                    || elType == TBrCtlDefs::EElementSmartLinkEmail
                    || elType == TBrCtlDefs::EElementSmartLinkVoip);
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::doTapL
//-----------------------------------------------------------------------------
void WebPointerEventHandler::doTapL()
{
    TBrCtlDefs::TBrCtlElementType elType = m_webview->focusedElementType();
    Frame* coreFrame = core(m_webview->mainFrame());
    
#ifdef BRDO_TOUCH_ENABLED_FF
    if (m_isHighlighted)
    {
        MTouchFeedback* feedback = MTouchFeedback::Instance();
        if (feedback)
           {
           feedback->InstantFeedback(ETouchFeedbackBasic);
           }
    }
#endif // BRDO_TOUCH_ENABLED_FF
    

     // We assume that if element visibility has been changed  
     // between "up" and "down" that means that some node event 
     // listener (onMouseOver etc) handling happened and we don't 
     // want to send a click (mouse press + mouse release) event.
     if (m_webview->page()->chrome()->client()->elementVisibilityChanged()) {
         return;
     }

     m_lastTapEvent.iPosition = m_buttonDownEvent.iPosition;
     m_lastTapEvent.iType = TPointerEvent::EButton1Up;
     m_lastTapEvent.iModifiers = 0;

    // don't pass the event if the text input is not in valid format
    if (isHighlitableElement(elType) || m_webview->fepTextEditor()->validateTextFormat()) {
        // because of scrolling we delay sending EButton1Down till we get EButton1Up event and if the content is not scrolling
        coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(m_buttonDownEvent));
        coreFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(m_lastTapEvent));
    }

    // special handling for broken image (why is this here??)
    if (m_webview->focusedElementType() == TBrCtlDefs::EElementBrokenImage) {
        loadFocusedImage(m_webview);
    }
    else if (elType == TBrCtlDefs::EElementActivatedObjectBox) {
        PluginSkin* plugin = m_webview->mainFrame()->focusedPlugin();
        if(plugin && plugin->pluginWin() && plugin->getClipRect().Contains(m_lastTapEvent.iPosition)){
            plugin->pluginWin()->HandlePointerEventL(m_lastTapEvent);
        }
    }
    else {
        m_webview->activateVirtualKeyboard();
    }
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::deHighlight
//-----------------------------------------------------------------------------
void  WebPointerEventHandler::dehighlight()
{
    // send dehighlight event to engine by passing -1, -1
    // sending any other pointer value may result in highligh of other links
    m_highlightPos = TPoint(-1, -1);
    m_isHighlighted = EFalse;
    TPointerEvent event;
    event.iType = TPointerEvent::EMove;
    event.iPosition = m_highlightPos;
    event.iModifiers = 0;

    Frame* coreFrame = core(m_webview->mainFrame());
    Frame* frm = m_webview->page()->focusController()->focusedOrMainFrame();
    frm->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event));

    
    m_highlightedNode = NULL;
       
    m_webview->syncRepaint();   
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::canDehighlight
//-----------------------------------------------------------------------------
 bool WebPointerEventHandler::canDehighlight(const TPoint &aPoint)
 {
    TBool checkDehighlight = true;

    if (!m_webview->viewIsScrolling())
    {
        WebFrame* frm = StaticObjectsContainer::instance()->webCursor()->getFrameUnderCursor();
        IntPoint framePoint = frm->frameView()->viewCoordsInFrameCoords(aPoint);
        if (m_highlightedNode->getRect().contains(framePoint)) {
            checkDehighlight = false;
        } // check if new points are coming towards closest element
        else if(m_offset) {
            //Calculate the new offset
           IntPoint nodePoint = m_highlightedNode->getRect().Rect().Center();
           TInt newoffset = (framePoint.x()- nodePoint.x())*(framePoint.x()- nodePoint.x()) + (framePoint.y()- nodePoint.y())*(framePoint.y()- nodePoint.y());

           if(newoffset <= m_offset ) {
                m_offset = newoffset;
                checkDehighlight = false;
           }
           else {
               m_offset =0;
               checkDehighlight = true;
           }
        }
    }

    return checkDehighlight;
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::buttonDownTimerCallback
//-----------------------------------------------------------------------------
void WebPointerEventHandler::buttonDownTimerCB(Timer<WebPointerEventHandler>* t)
{
    m_buttonDownTimer.stop();

    WebCursor*  cursor = StaticObjectsContainer::instance()->webCursor();
    
    Frame* coreFrame = core(m_webview->mainFrame());
    TPointerEvent event;
    
    TBrCtlDefs::TBrCtlElementType elType = highlitableElement();
    
    if (!isHighlitableElement(elType)) {
        elType = TBrCtlDefs::EElementNone;
    }
    m_isHighlighted = (m_highlightedNode != NULL) && (elType != TBrCtlDefs::EElementNone) ;
    
    event.iPosition = m_highlightPos;
    event.iModifiers = 0;
    event.iType = TPointerEvent::EMove;

    coreFrame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event));
    m_waiter->AsyncStop();
}


//-----------------------------------------------------------------------------
// WebPointerEventHandler::updateCursor
//----------------------------------------------------------------------------
void WebPointerEventHandler::updateCursor(const TPoint& pos)
{
    WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
    if (cursor) {
        if (pos != TPoint(0, 0)) {
            cursor->setPosition(pos);
        }
        if (m_webview->showCursor()) {
            cursor->resetTransparency();
            m_webview->setShowCursor(false);
            cursor->cursorUpdate(false); 
        }
    }
}
