/*

 * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "EventHandler.h"

#include "AXObjectCache.h"

#include "CachedImage.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Cursor.h"

#include "Document.h"

#include "DragController.h"

#include "Editor.h"

#include "EventNames.h"

#include "FloatPoint.h"

#include "FloatRect.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HTMLFrameElementBase.h"

#include "HTMLFrameSetElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "Image.h"

#include "InspectorController.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "MouseEventWithHitTestResults.h"

#include "Page.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformWheelEvent.h"

#include "PluginDocument.h"

#include "RenderFrameSet.h"

#include "RenderLayer.h"

#include "RenderTextControlSingleLine.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "Scrollbar.h"

#include "SelectionController.h"

#include "Settings.h"

#include "TextEvent.h"

#include "TextIterator.h"

#include "UserGestureIndicator.h"

#include "WheelEvent.h"

#include "htmlediting.h" // for comparePositions()

#include <wtf/CurrentTime.h>

#include <wtf/StdLibExtras.h>

#if ENABLE(SVG)

#include "SVGDocument.h"

#include "SVGElementInstance.h"

#include "SVGNames.h"

#include "SVGUseElement.h"

#endif

#if ENABLE(TOUCH_EVENTS)

#include "PlatformTouchEvent.h"

#include "TouchEvent.h"

#if ENABLE(TRANSFORMACTION_EVENTS)

#include "TransformActionEvent.h"

#endif

#endif

#if ENABLE(HAPTICS)

#include "PlatformHaptics.h"

#endif

namespace WebCore {

using namespace HTMLNames;

#if ENABLE(DRAG_SUPPORT)

// The link drag hysteresis is much larger than the others because there

// needs to be enough space to cancel the link press without starting a link drag,

// and because dragging links is rare.

const int LinkDragHysteresis = 40;

const int ImageDragHysteresis = 5;

const int TextDragHysteresis = 3;

const int GeneralDragHysteresis = 3;

#endif // ENABLE(DRAG_SUPPORT)

// Match key code of composition keydown event on windows.

// IE sends VK_PROCESSKEY which has value 229;

const int CompositionEventKeyCode = 229;

#if ENABLE(SVG)

using namespace SVGNames;

#endif

// When the autoscroll or the panScroll is triggered when do the scroll every 0.05s to make it smooth

const double autoscrollInterval = 0.05;

const double fakeMouseMoveInterval = 0.1;

static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);

static inline bool scrollNode(float delta, WheelEvent::Granularity granularity, ScrollDirection positiveDirection, ScrollDirection negativeDirection, Node* node, Node** stopNode)

{

    if (!delta)

        return false;

    if (!node->renderer())

        return false;

    // Find the nearest enclosing box.

    RenderBox* enclosingBox = node->renderer()->enclosingBox();

    float absDelta = delta > 0 ? delta : -delta;

    if (granularity == WheelEvent::Page)

        return enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, ScrollByPage, absDelta, stopNode);

    if (granularity == WheelEvent::Line)

        return enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, ScrollByLine, absDelta, stopNode);

    if (granularity == WheelEvent::Pixel)

        return enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, ScrollByPixel, absDelta, stopNode);

    return false;

}

#if !PLATFORM(MAC)

inline bool EventHandler::eventLoopHandleMouseUp(const MouseEventWithHitTestResults&)

{

    return false;

}

#if ENABLE(DRAG_SUPPORT)

inline bool EventHandler::eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&)

{

    return false;

}

#endif

#endif

EventHandler::EventHandler(Frame* frame)

    : m_frame(frame)

    , m_mousePressed(false)

    , m_capturesDragging(false)

    , m_mouseDownMayStartSelect(false)

#if ENABLE(DRAG_SUPPORT)

    , m_mouseDownMayStartDrag(false)

#endif

    , m_mouseDownWasSingleClickInSelection(false)

    , m_beganSelectingText(false)

    , m_panScrollInProgress(false)

    , m_panScrollButtonPressed(false)

    , m_springLoadedPanScrollInProgress(false)

    , m_hoverTimer(this, &EventHandler::hoverTimerFired)

    , m_autoscrollTimer(this, &EventHandler::autoscrollTimerFired)

    , m_autoscrollRenderer(0)

    , m_autoscrollInProgress(false)

    , m_mouseDownMayStartAutoscroll(false)

    , m_mouseDownWasInSubframe(false)

    , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)

#if ENABLE(SVG)

    , m_svgPan(false)

#endif

    , m_resizeLayer(0)

    , m_eventHandlerWillResetCapturingMouseEventsNode(0)

    , m_clickCount(0)

    , m_mouseDownTimestamp(0)

    , m_useLatchedWheelEventNode(false)

    , m_widgetIsLatched(false)

#if PLATFORM(MAC)

    , m_mouseDownView(nil)

    , m_sendingEventToSubview(false)

    , m_activationEventNumber(0)

#endif

#if ENABLE(TOUCH_EVENTS)

    , m_touchPressed(false)

#endif

#if ENABLE(HAPTICS)

    , m_firstTouchedNode(0)

    , m_hapticFeedbackCancelled(false)

#endif

{

#if ENABLE(HAPTICS)

    initHaptics();

#endif

}

EventHandler::~EventHandler()

{

    ASSERT(!m_fakeMouseMoveEventTimer.isActive());

}

#if ENABLE(DRAG_SUPPORT)

EventHandler::EventHandlerDragState& EventHandler::dragState()

{

    DEFINE_STATIC_LOCAL(EventHandlerDragState, state, ());

    return state;

}

#endif // ENABLE(DRAG_SUPPORT)

void EventHandler::clear()

{

    m_hoverTimer.stop();

    m_fakeMouseMoveEventTimer.stop();

    m_resizeLayer = 0;

    m_nodeUnderMouse = 0;

    m_lastNodeUnderMouse = 0;

#if ENABLE(SVG)

    m_instanceUnderMouse = 0;

    m_lastInstanceUnderMouse = 0;

#endif

    m_lastMouseMoveEventSubframe = 0;

    m_lastScrollbarUnderMouse = 0;

    m_clickCount = 0;

    m_clickNode = 0;

    m_frameSetBeingResized = 0;

#if ENABLE(DRAG_SUPPORT)

    m_dragTarget = 0;

    m_shouldOnlyFireDragOverEvent = false;

#endif

    m_currentMousePosition = IntPoint();

    m_mousePressNode = 0;

    m_mousePressed = false;

    m_capturesDragging = false;

    m_capturingMouseEventsNode = 0;

    m_latchedWheelEventNode = 0;

    m_previousWheelScrolledNode = 0;

#if ENABLE(TOUCH_EVENTS)

    m_originatingTouchPointTargets.clear();

#endif

}

void EventHandler::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)

{

    Node* innerNode = result.targetNode();

    VisibleSelection newSelection;

    if (innerNode && innerNode->renderer() && m_mouseDownMayStartSelect) {

        VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));

        TextGranularity granularity = CharacterGranularity;

        if (pos.isNotNull()) {

            newSelection = VisibleSelection(pos);

            newSelection.expandUsingGranularity(WordGranularity);

        }

        if (newSelection.isRange()) {

            granularity = WordGranularity;

            m_beganSelectingText = true;

            if (result.event().clickCount() == 2 && m_frame->editor()->isSelectTrailingWhitespaceEnabled()) 

                newSelection.appendTrailingWhitespace();            

        }

        if (m_frame->shouldChangeSelection(newSelection))

            m_frame->selection()->setSelection(newSelection, granularity, MakeNonDirectionalSelection);

    }

}

void EventHandler::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result)

{

    if (!result.hitTestResult().isLiveLink())

        return selectClosestWordFromMouseEvent(result);

    Node* innerNode = result.targetNode();

    if (innerNode && innerNode->renderer() && m_mouseDownMayStartSelect) {

        VisibleSelection newSelection;

        Element* URLElement = result.hitTestResult().URLElement();

        VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));

        if (pos.isNotNull() && pos.deepEquivalent().node()->isDescendantOf(URLElement))

            newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);

        TextGranularity granularity = CharacterGranularity;

        if (newSelection.isRange()) {

            granularity = WordGranularity;

            m_beganSelectingText = true;

        }

        if (m_frame->shouldChangeSelection(newSelection))

            m_frame->selection()->setSelection(newSelection, granularity, MakeNonDirectionalSelection);

    }

}

bool EventHandler::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)

{

    if (event.event().button() != LeftButton)

        return false;

    if (m_frame->selection()->isRange())

        // A double-click when range is already selected

        // should not change the selection.  So, do not call

        // selectClosestWordFromMouseEvent, but do set

        // m_beganSelectingText to prevent handleMouseReleaseEvent

        // from setting caret selection.

        m_beganSelectingText = true;

    else

        selectClosestWordFromMouseEvent(event);

    return true;

}

bool EventHandler::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)

{

    if (event.event().button() != LeftButton)

        return false;

    Node* innerNode = event.targetNode();

    if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))

        return false;

    VisibleSelection newSelection;

    VisiblePosition pos(innerNode->renderer()->positionForPoint(event.localPoint()));

    if (pos.isNotNull()) {

        newSelection = VisibleSelection(pos);

        newSelection.expandUsingGranularity(ParagraphGranularity);

    }

    TextGranularity granularity = CharacterGranularity;

    if (newSelection.isRange()) {

        granularity = ParagraphGranularity;

        m_beganSelectingText = true;

    }

    if (m_frame->shouldChangeSelection(newSelection))

        m_frame->selection()->setSelection(newSelection, granularity, MakeNonDirectionalSelection);

    return true;

}

static int textDistance(const Position& start, const Position& end)

{

     RefPtr<Range> range = Range::create(start.node()->document(), start, end);

     return TextIterator::rangeLength(range.get(), true);

}

bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)

{

    Node* innerNode = event.targetNode();

    if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))

        return false;

    // Extend the selection if the Shift key is down, unless the click is in a link.

    bool extendSelection = event.event().shiftKey() && !event.isOverLink();

    // Don't restart the selection when the mouse is pressed on an

    // existing selection so we can allow for text dragging.

    if (FrameView* view = m_frame->view()) {

        IntPoint vPoint = view->windowToContents(event.event().pos());

        if (!extendSelection && m_frame->selection()->contains(vPoint)) {

            m_mouseDownWasSingleClickInSelection = true;

            return false;

        }

    }

    VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(event.localPoint()));

    if (visiblePos.isNull())

        visiblePos = VisiblePosition(innerNode, 0, DOWNSTREAM);

    Position pos = visiblePos.deepEquivalent();

    VisibleSelection newSelection = m_frame->selection()->selection();

    TextGranularity granularity = CharacterGranularity;

    if (extendSelection && newSelection.isCaretOrRange()) {

        m_frame->selection()->setIsDirectional(false);

        ASSERT(m_frame->settings());

        if (m_frame->settings()->editingBehaviorType() == EditingMacBehavior) {

            // See <rdar://problem/3668157> REGRESSION (Mail): shift-click deselects when selection

            // was created right-to-left

            Position start = newSelection.start();

            Position end = newSelection.end();

            int distanceToStart = textDistance(start, pos);

            int distanceToEnd = textDistance(pos, end);

            if (distanceToStart <= distanceToEnd)

                newSelection = VisibleSelection(end, pos);

            else

                newSelection = VisibleSelection(start, pos);

        } else {

            newSelection.setExtent(pos);

        }

        if (m_frame->selectionGranularity() != CharacterGranularity) {

            granularity = m_frame->selectionGranularity();

            newSelection.expandUsingGranularity(m_frame->selectionGranularity());

        }

        m_beganSelectingText = true;

    } else

        newSelection = VisibleSelection(visiblePos);

    if (m_frame->shouldChangeSelection(newSelection))

        m_frame->selection()->setSelection(newSelection, granularity, MakeNonDirectionalSelection);

    return true;

}

bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)

{

#if ENABLE(DRAG_SUPPORT)

    // Reset drag state.

    dragState().m_dragSrc = 0;

#endif

    cancelFakeMouseMoveEvent();

    if (ScrollView* scrollView = m_frame->view()) {

        if (scrollView->isPointInScrollbarCorner(event.event().pos()))

            return false;

    }

    bool singleClick = event.event().clickCount() <= 1;

    // If we got the event back, that must mean it wasn't prevented,

    // so it's allowed to start a drag or selection.

    m_mouseDownMayStartSelect = canMouseDownStartSelect(event.targetNode());

#if ENABLE(DRAG_SUPPORT)

    // Careful that the drag starting logic stays in sync with eventMayStartDrag()

    m_mouseDownMayStartDrag = singleClick;

#endif

    m_mouseDownWasSingleClickInSelection = false;

    m_mouseDown = event.event();

    if (event.isOverWidget() && passWidgetMouseDownEventToWidget(event))

        return true;

#if ENABLE(SVG)

    if (m_frame->document()->isSVGDocument()

        && static_cast<SVGDocument*>(m_frame->document())->zoomAndPanEnabled()) {

        if (event.event().shiftKey() && singleClick) {

            m_svgPan = true;

            static_cast<SVGDocument*>(m_frame->document())->startPan(event.event().pos());

            return true;

        }

    }

#endif

    // We don't do this at the start of mouse down handling,

    // because we don't want to do it until we know we didn't hit a widget.

    if (singleClick)

        focusDocumentView();

    Node* innerNode = event.targetNode();

    m_mousePressNode = innerNode;

#if ENABLE(DRAG_SUPPORT)

    m_dragStartPos = event.event().pos();

#endif

    bool swallowEvent = false;

    m_mousePressed = true;

    m_beganSelectingText = false;

    if (event.event().clickCount() == 2)

        swallowEvent = handleMousePressEventDoubleClick(event);

    else if (event.event().clickCount() >= 3)

        swallowEvent = handleMousePressEventTripleClick(event);

    else

        swallowEvent = handleMousePressEventSingleClick(event);

    m_mouseDownMayStartAutoscroll = m_mouseDownMayStartSelect

        || (m_mousePressNode && m_mousePressNode->renderBox() && m_mousePressNode->renderBox()->canBeProgramaticallyScrolled(true));

    return swallowEvent;

}

// There are two kinds of renderer that can autoscroll.

static bool canAutoscroll(RenderObject* renderer)

{

    if (!renderer->isBox())

        return false;

    // Check for a box that can be scrolled in its own right.

    if (toRenderBox(renderer)->canBeScrolledAndHasScrollableArea())

        return true;

    // Check for a box that represents the top level of a web page.

    // This can be scrolled by calling Chrome::scrollRectIntoView.

    // This only has an effect on the Mac platform in applications

    // that put web views into scrolling containers, such as Mac OS X Mail.

    // The code for this is in RenderLayer::scrollRectToVisible.

    if (renderer->node() != renderer->document())

        return false;

    Frame* frame = renderer->frame();

    if (!frame)

        return false;

    Page* page = frame->page();

    return page && page->mainFrame() == frame;

}

#if ENABLE(DRAG_SUPPORT)

bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)

{

    if (handleDrag(event))

        return true;

    if (!m_mousePressed)

        return false;

    Node* targetNode = event.targetNode();

    if (event.event().button() != LeftButton || !targetNode || !targetNode->renderer())

        return false;