/*

 * Copyright (C) 2006, 2007 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 "CachedImage.h"

#include "ChromeClient.h"

#include "Cursor.h"

#include "Document.h"

#include "DragController.h"

#include "Editor.h"

#include "EventNames.h"

#include "FloatPoint.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "HTMLFrameSetElement.h"

#include "HTMLFrameElementBase.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "Image.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "MouseEventWithHitTestResults.h"

#include "Page.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformScrollBar.h"

#include "PlatformWheelEvent.h"

#include "RenderWidget.h"

#include "SelectionController.h"

#include "Settings.h"

#include "TextEvent.h"

#if ENABLE(SVG)

#include "SVGCursorElement.h"

#include "SVGDocument.h"

#include "SVGLength.h"

#include "SVGNames.h"

#endif

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

// 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;

const double TextDragDelay = 0.15;

// 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

const double autoscrollInterval = 0.1;

static Frame* subframeForTargetNode(Node* node);

EventHandler::EventHandler(Frame* frame)

    : m_frame(frame)

    , m_mousePressed(false)

    , m_mouseDownMayStartSelect(false)

    , m_mouseDownMayStartDrag(false)

    , m_mouseDownWasSingleClickInSelection(false)

    , m_beganSelectingText(false)

    , m_hoverTimer(this, &EventHandler::hoverTimerFired)

    , m_autoscrollTimer(this, &EventHandler::autoscrollTimerFired)

    , m_autoscrollRenderer(0)

    , m_mouseDownMayStartAutoscroll(false)

    , m_mouseDownWasInSubframe(false)

#if ENABLE(SVG)

    , m_svgPan(false)

#endif

    , m_resizeLayer(0)

    , m_capturingMouseEventsNode(0)

    , m_clickCount(0)

    , m_mouseDownTimestamp(0)

#if PLATFORM(MAC)

    , m_mouseDownView(nil)

    , m_sendingEventToSubview(false)

    , m_activationEventNumber(0)

#endif

{

}

EventHandler::~EventHandler()

{

}

EventHandler::EventHandlerDragState& EventHandler::dragState()

{

    static EventHandlerDragState state;

    return state;

}

void EventHandler::clear()

{

    m_hoverTimer.stop();

    m_resizeLayer = 0;

    m_nodeUnderMouse = 0;

    m_lastNodeUnderMouse = 0;

    m_lastMouseMoveEventSubframe = 0;

    m_lastScrollbarUnderMouse = 0;

    m_clickCount = 0;

    m_clickNode = 0;

    m_frameSetBeingResized = 0;

    m_dragTarget = 0;

    m_currentMousePosition = IntPoint();

    m_mousePressNode = 0;

    m_mousePressed = false;

    m_capturingMouseEventsNode = 0;

}

void EventHandler::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)

{

    Node* innerNode = result.targetNode();

    Selection newSelection;

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

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

        if (pos.isNotNull()) {

            newSelection = Selection(pos);

            newSelection.expandUsingGranularity(WordGranularity);

        }

        if (newSelection.isRange()) {

            m_frame->setSelectionGranularity(WordGranularity);

            m_beganSelectingText = true;

        }

        if (m_frame->shouldChangeSelection(newSelection))

            m_frame->selectionController()->setSelection(newSelection);

    }

}

bool EventHandler::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)

{

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

        return false;

    if (m_frame->selectionController()->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;

    Selection newSelection;

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

    if (pos.isNotNull()) {

        newSelection = Selection(pos);

        newSelection.expandUsingGranularity(ParagraphGranularity);

    }

    if (newSelection.isRange()) {

        m_frame->setSelectionGranularity(ParagraphGranularity);

        m_beganSelectingText = true;

    }

    if (m_frame->shouldChangeSelection(newSelection))

        m_frame->selectionController()->setSelection(newSelection);

    return true;

}

bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)

{

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

        return false;

    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.

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

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

        m_mouseDownWasSingleClickInSelection = true;

        return false;

    }

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

    if (visiblePos.isNull())

        visiblePos = VisiblePosition(innerNode, innerNode->caretMinOffset(), DOWNSTREAM);

    Position pos = visiblePos.deepEquivalent();

    Selection newSelection = m_frame->selectionController()->selection();

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

        m_frame->selectionController()->setLastChangeWasHorizontalExtension(false);

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

        // was created right-to-left

        Position start = newSelection.start();

        Position end = newSelection.end();

        short before = Range::compareBoundaryPoints(pos.node(), pos.offset(), start.node(), start.offset());

        if (before <= 0)

            newSelection = Selection(pos, end);

        else

            newSelection = Selection(start, pos);

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

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

        m_beganSelectingText = true;

    } else {

        newSelection = Selection(visiblePos);

        m_frame->setSelectionGranularity(CharacterGranularity);

    }

    if (m_frame->shouldChangeSelection(newSelection))

        m_frame->selectionController()->setSelection(newSelection);

    return true;

}

bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)

{

    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());

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

    m_mouseDownMayStartDrag = singleClick;

    m_mouseDownWasSingleClickInSelection = false;

    if (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;

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

    bool swallowEvent = false;

    if (event.event().button() == LeftButton || event.event().button() == MiddleButton) {

        m_frame->selectionController()->setCaretBlinkingSuspended(true);

        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->renderer() && m_mousePressNode->renderer()->shouldAutoscroll());

   return swallowEvent;

}

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;

#if PLATFORM(MAC) // FIXME: Why does this assertion fire on other platforms?

    ASSERT(m_mouseDownMayStartSelect || m_mouseDownMayStartAutoscroll);

#endif

    m_mouseDownMayStartDrag = false;

    if (m_mouseDownMayStartAutoscroll) {            

        // If the selection is contained in a layer that can scroll, that layer should handle the autoscroll

        // Otherwise, let the bridge handle it so the view can scroll itself.

        RenderObject* renderer = targetNode->renderer();

        while (renderer && !renderer->shouldAutoscroll())

            renderer = renderer->parent();

        if (renderer)

            handleAutoscroll(renderer);

    }

    updateSelectionForMouseDrag(targetNode, event.localPoint());

    return true;

}

bool EventHandler::eventMayStartDrag(const PlatformMouseEvent& event) const

{

    // This is a pre-flight check of whether the event might lead to a drag being started.  Be careful

    // that its logic needs to stay in sync with handleMouseMoveEvent() and the way we setMouseDownMayStartDrag

    // in handleMousePressEvent

    if (!m_frame->renderer() || !m_frame->renderer()->hasLayer()

        || event.button() != LeftButton || event.clickCount() != 1)

        return false;

    bool DHTMLFlag;

    bool UAFlag;

    allowDHTMLDrag(DHTMLFlag, UAFlag);

    if (!DHTMLFlag && !UAFlag)

        return false;

    HitTestRequest request(true, false);

    HitTestResult result(m_frame->view()->windowToContents(event.pos()));

    m_frame->renderer()->layer()->hitTest(request, result);

    bool srcIsDHTML;

    return result.innerNode() && result.innerNode()->renderer()->draggableNode(DHTMLFlag, UAFlag, result.point().x(), result.point().y(), srcIsDHTML);

}

void EventHandler::updateSelectionForMouseDrag()

{

    FrameView* view = m_frame->view();

    if (!view)

        return;

    RenderObject* renderer = m_frame->renderer();

    if (!renderer)

        return;

    RenderLayer* layer = renderer->layer();

    if (!layer)

        return;

    HitTestResult result(view->windowToContents(m_currentMousePosition));

    layer->hitTest(HitTestRequest(true, true, true), result);

    updateSelectionForMouseDrag(result.innerNode(), result.localPoint());

}

void EventHandler::updateSelectionForMouseDrag(Node* targetNode, const IntPoint& localPoint)

{

    if (!m_mouseDownMayStartSelect)

        return;

    if (!targetNode)

        return;

    RenderObject* targetRenderer = targetNode->renderer();

    if (!targetRenderer)

        return;

    if (!canMouseDragExtendSelect(targetNode))

        return;

    VisiblePosition targetPosition(targetRenderer->positionForPoint(localPoint));

    // Don't modify the selection if we're not on a node.

    if (targetPosition.isNull())

        return;

    // Restart the selection if this is the first mouse move. This work is usually

    // done in handleMousePressEvent, but not if the mouse press was on an existing selection.

    Selection newSelection = m_frame->selectionController()->selection();

#if ENABLE(SVG)

    // Special case to limit selection to the containing block for SVG text.

    // FIXME: Isn't there a better non-SVG-specific way to do this?

    if (Node* selectionBaseNode = newSelection.base().node())

        if (RenderObject* selectionBaseRenderer = selectionBaseNode->renderer())

            if (selectionBaseRenderer->isSVGText())

                if (targetNode->renderer()->containingBlock() != selectionBaseRenderer->containingBlock())

                    return;

#endif

    if (!m_beganSelectingText) {

        m_beganSelectingText = true;

        newSelection = Selection(targetPosition);

    }

    newSelection.setExtent(targetPosition);

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

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

    if (m_frame->shouldChangeSelection(newSelection)) {

        m_frame->selectionController()->setLastChangeWasHorizontalExtension(false);

        m_frame->selectionController()->setSelection(newSelection);

    }

}

bool EventHandler::handleMouseUp(const MouseEventWithHitTestResults& event)

{

    if (eventLoopHandleMouseUp(event))

        return true;

    // If this was the first click in the window, we don't even want to clear the selection.

    // This case occurs when the user clicks on a draggable element, since we have to process

    // the mouse down and drag events to see if we might start a drag.  For other first clicks

    // in a window, we just don't acceptFirstMouse, and the whole down-drag-up sequence gets

    // ignored upstream of this layer.

    return eventActivatedView(event.event());

}    

bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)

{

    stopAutoscrollTimer();

    if (handleMouseUp(event))

        return true;

    // Used to prevent mouseMoveEvent from initiating a drag before

    // the mouse is pressed again.

    m_frame->selectionController()->setCaretBlinkingSuspended(false);

    m_mousePressed = false;

    m_mouseDownMayStartDrag = false;

    m_mouseDownMayStartSelect = false;

    m_mouseDownMayStartAutoscroll = false;

    m_mouseDownWasInSubframe = false;

    bool handled = false;

    // Clear the selection if the mouse didn't move after the last mouse press.

    // We do this so when clicking on the selection, the selection goes away.

    // However, if we are editing, place the caret.

    if (m_mouseDownWasSingleClickInSelection && !m_beganSelectingText

            && m_dragStartPos == event.event().pos()

            && m_frame->selectionController()->isRange()) {

        Selection newSelection;

        Node *node = event.targetNode();

        if (node && node->isContentEditable() && node->renderer()) {

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

            newSelection = Selection(pos);

        }

        if (m_frame->shouldChangeSelection(newSelection))

            m_frame->selectionController()->setSelection(newSelection);

        handled = true;

    }

    m_frame->notifyRendererOfSelectionChange(true);

    m_frame->selectionController()->selectFrameElementInParentIfFullySelected();

    return handled;

}

void EventHandler::handleAutoscroll(RenderObject* renderer)

{

    if (m_autoscrollTimer.isActive())

        return;

    setAutoscrollRenderer(renderer);

    startAutoscrollTimer();

}

void EventHandler::autoscrollTimerFired(Timer<EventHandler>*)

{

    if (!m_mousePressed) {

        stopAutoscrollTimer();

        return;

    }

    if (RenderObject* r = autoscrollRenderer())

        r->autoscroll();

}

RenderObject* EventHandler::autoscrollRenderer() const

{

    return m_autoscrollRenderer;

}

void EventHandler::setAutoscrollRenderer(RenderObject* renderer)

{