/*

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

 *

 * 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 "SelectionController.h"

#include "DeleteSelectionCommand.h"

#include "Document.h"

#include "Editor.h"

#include "Element.h"

#include "EventHandler.h"

#include "ExceptionCode.h"

#include "FloatQuad.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameTree.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLFrameOwnerElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "Page.h"

#include "Range.h"

#include "RenderLayer.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "SecureTextInput.h"

#include "Settings.h"

#include "TextIterator.h"

#include "TypingCommand.h"

#include "htmlediting.h"

#include "visible_units.h"

#include <stdio.h>

#include <wtf/text/CString.h>

#define EDIT_DEBUG 0

namespace WebCore {

using namespace HTMLNames;

const int NoXPosForVerticalArrowNavigation = INT_MIN;

SelectionController::SelectionController(Frame* frame, bool isDragCaretController)

    : m_frame(frame)

    , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation)

    , m_granularity(CharacterGranularity)

    , m_caretBlinkTimer(this, &SelectionController::caretBlinkTimerFired)

    , m_needsLayout(true)

    , m_absCaretBoundsDirty(true)

    , m_isDragCaretController(isDragCaretController)

    , m_isCaretBlinkingSuspended(false)

    , m_focused(frame && frame->page() && frame->page()->focusController()->focusedFrame() == frame)

    , m_caretVisible(isDragCaretController)

    , m_caretPaint(true)

{

    setIsDirectional(false);

}

void SelectionController::moveTo(const VisiblePosition &pos, bool userTriggered, CursorAlignOnScroll align)

{

    setSelection(VisibleSelection(pos.deepEquivalent(), pos.deepEquivalent(), pos.affinity()), true, true, userTriggered, align);

}

void SelectionController::moveTo(const VisiblePosition &base, const VisiblePosition &extent, bool userTriggered)

{

    setSelection(VisibleSelection(base.deepEquivalent(), extent.deepEquivalent(), base.affinity()), true, true, userTriggered);

}

void SelectionController::moveTo(const Position &pos, EAffinity affinity, bool userTriggered)

{

    setSelection(VisibleSelection(pos, affinity), true, true, userTriggered);

}

void SelectionController::moveTo(const Range *r, EAffinity affinity, bool userTriggered)

{

    VisibleSelection selection = r ? VisibleSelection(r->startPosition(), r->endPosition(), affinity) : VisibleSelection(Position(), Position(), affinity);

    setSelection(selection, true, true, userTriggered);

}

void SelectionController::moveTo(const Position &base, const Position &extent, EAffinity affinity, bool userTriggered)

{

    setSelection(VisibleSelection(base, extent, affinity), true, true, userTriggered);

}

void SelectionController::setSelection(const VisibleSelection& s, bool closeTyping, bool clearTypingStyle, bool userTriggered, CursorAlignOnScroll align, TextGranularity granularity, DirectionalityPolicy directionalityPolicy)

{

    m_granularity = granularity;

    setIsDirectional(directionalityPolicy == MakeDirectionalSelection);

    if (m_isDragCaretController) {

        invalidateCaretRect();

        m_selection = s;

        m_needsLayout = true;

        invalidateCaretRect();

        return;

    }

    if (!m_frame) {

        m_selection = s;

        return;

    }

    Node* baseNode = s.base().node();

    Document* document = 0;

    if (baseNode)

        document = baseNode->document();

    // <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at SelectionController::setSelection

    // if document->frame() == m_frame we can get into an infinite loop

    if (document && document->frame() && document->frame() != m_frame && document != m_frame->document()) {

        document->frame()->selection()->setSelection(s, closeTyping, clearTypingStyle, userTriggered);

        return;

    }

    if (closeTyping)

        TypingCommand::closeTyping(m_frame->editor()->lastEditCommand());

    if (clearTypingStyle)

        m_frame->clearTypingStyle();

    if (m_selection == s)

        return;

    VisibleSelection oldSelection = m_selection;

    m_selection = s;

    m_needsLayout = true;

    if (!s.isNone())

        m_frame->setFocusedNodeIfNeeded();

    updateAppearance();

    // Always clear the x position used for vertical arrow navigation.

    // It will be restored by the vertical arrow navigation code if necessary.

    m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation;

    selectFrameElementInParentIfFullySelected();

    m_frame->notifyRendererOfSelectionChange(userTriggered);

    m_frame->respondToChangedSelection(oldSelection, closeTyping);

    if (userTriggered) {

        ScrollAlignment alignment;

        if (m_frame->editor()->behavior().shouldCenterAlignWhenSelectionIsRevealed())

            alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded;

        else

            alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded;

        m_frame->revealSelection(alignment, true);

    }

    notifyAccessibilityForSelectionChange();

}

static bool removingNodeRemovesPosition(Node* node, const Position& position)

{

    if (!position.node())

        return false;

    if (position.node() == node)

        return true;

    if (!node->isElementNode())

        return false;

    Element* element = static_cast<Element*>(node);

    return element->contains(position.node()) || element->contains(position.node()->shadowAncestorNode());

}

void SelectionController::nodeWillBeRemoved(Node *node)

{

    if (isNone())

        return;

    // There can't be a selection inside a fragment, so if a fragment's node is being removed,

    // the selection in the document that created the fragment needs no adjustment.

    if (node && highestAncestor(node)->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)

        return;

    bool baseRemoved = removingNodeRemovesPosition(node, m_selection.base());

    bool extentRemoved = removingNodeRemovesPosition(node, m_selection.extent());

    bool startRemoved = removingNodeRemovesPosition(node, m_selection.start());

    bool endRemoved = removingNodeRemovesPosition(node, m_selection.end());

    bool clearRenderTreeSelection = false;

    bool clearDOMTreeSelection = false;

    if (startRemoved || endRemoved) {

        // FIXME: When endpoints are removed, we should just alter the selection, instead of blowing it away.

        clearRenderTreeSelection = true;

        clearDOMTreeSelection = true;

    } else if (baseRemoved || extentRemoved) {

        // The base and/or extent are about to be removed, but the start and end aren't.

        // Change the base and extent to the start and end, but don't re-validate the

        // selection, since doing so could move the start and end into the node

        // that is about to be removed.

        if (m_selection.isBaseFirst())

            m_selection.setWithoutValidation(m_selection.start(), m_selection.end());

        else

            m_selection.setWithoutValidation(m_selection.end(), m_selection.start());

    // FIXME: This could be more efficient if we had an isNodeInRange function on Ranges.

    } else if (comparePositions(m_selection.start(), Position(node, 0)) == -1 && comparePositions(m_selection.end(), Position(node, 0)) == 1) {

        // If we did nothing here, when this node's renderer was destroyed, the rect that it 

        // occupied would be invalidated, but, selection gaps that change as a result of 

        // the removal wouldn't be invalidated.

        // FIXME: Don't do so much unnecessary invalidation.

        clearRenderTreeSelection = true;

    }

    if (clearRenderTreeSelection) {

        RefPtr<Document> document = m_selection.start().node()->document();

        document->updateStyleIfNeeded();

        if (RenderView* view = toRenderView(document->renderer()))

            view->clearSelection();

    }

    if (clearDOMTreeSelection)

        setSelection(VisibleSelection(), false, false);

}

void SelectionController::setIsDirectional(bool isDirectional)

{

    m_isDirectional = !m_frame || m_frame->editor()->behavior().shouldConsiderSelectionAsDirectional() || isDirectional;

}

void SelectionController::willBeModified(EAlteration alter, EDirection direction)

{

    if (alter != AlterationExtend)

        return;

    Position start = m_selection.start();

    Position end = m_selection.end();

    if (m_isDirectional) {

        // Make base and extent match start and end so we extend the user-visible selection.

        // This only matters for cases where base and extend point to different positions than

        // start and end (e.g. after a double-click to select a word).

        if (m_selection.isBaseFirst()) {

            m_selection.setBase(start);

            m_selection.setExtent(end);            

        } else {

            m_selection.setBase(end);

            m_selection.setExtent(start);

        }

    } else {

        // FIXME: This is probably not correct for right and left when the direction is RTL.

        switch (direction) {

        case DirectionRight:

        case DirectionForward:

            m_selection.setBase(start);

            m_selection.setExtent(end);

            break;

        case DirectionLeft:

        case DirectionBackward:

            m_selection.setBase(end);

            m_selection.setExtent(start);

            break;

        }

    }

}

TextDirection SelectionController::directionOfEnclosingBlock()

{

    Node* n = m_selection.extent().node();

    Node* enclosingBlockNode = enclosingBlock(n);

    if (!enclosingBlockNode)

        return LTR;

    RenderObject* renderer = enclosingBlockNode->renderer();

    if (renderer)

        return renderer->style()->direction();

    return LTR;

}

VisiblePosition SelectionController::positionForPlatform(bool isGetStart) const

{

    Position pos;

    Settings* settings = m_frame ? m_frame->settings() : 0;

    if (settings && settings->editingBehaviorType() == EditingMacBehavior)

        pos = isGetStart ? m_selection.start() : m_selection.end();

    else {

        // Linux and Windows always extend selections from the extent endpoint.

        // FIXME: VisibleSelection should be fixed to ensure as an invariant that

        // base/extent always point to the same nodes as start/end, but which points

        // to which depends on the value of isBaseFirst. Then this can be changed

        // to just return m_sel.extent().

        pos = m_selection.isBaseFirst() ? m_selection.end() : m_selection.start();

    }

    return VisiblePosition(pos, m_selection.affinity());

}

VisiblePosition SelectionController::startForPlatform() const

{

    return positionForPlatform(true);

}

VisiblePosition SelectionController::endForPlatform() const

{

    return positionForPlatform(false);

}

VisiblePosition SelectionController::modifyExtendingRight(TextGranularity granularity)

{

    VisiblePosition pos(m_selection.extent(), m_selection.affinity());

    // The difference between modifyExtendingRight and modifyExtendingForward is:

    // modifyExtendingForward always extends forward logically.

    // modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,

    // it extends forward logically if the enclosing block is LTR direction,

    // but it extends backward logically if the enclosing block is RTL direction.

    switch (granularity) {

    case CharacterGranularity:

        if (directionOfEnclosingBlock() == LTR)

            pos = pos.next(true);

        else

            pos = pos.previous(true);

        break;

    case WordGranularity:

        if (directionOfEnclosingBlock() == LTR)

            pos = nextWordPosition(pos);

        else

            pos = previousWordPosition(pos);

        break;

    case SentenceGranularity:

    case LineGranularity:

    case ParagraphGranularity:

    case SentenceBoundary:

    case LineBoundary:

    case ParagraphBoundary:

    case DocumentBoundary:

        // FIXME: implement all of the above?

        pos = modifyExtendingForward(granularity);

    }

    return pos;

}

VisiblePosition SelectionController::modifyExtendingForward(TextGranularity granularity)

{

    VisiblePosition pos(m_selection.extent(), m_selection.affinity());

    switch (granularity) {

    case CharacterGranularity:

        pos = pos.next(true);

        break;

    case WordGranularity:

        pos = nextWordPosition(pos);

        break;

    case SentenceGranularity:

        pos = nextSentencePosition(pos);

        break;

    case LineGranularity:

        pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));

        break;

    case ParagraphGranularity:

        pos = nextParagraphPosition(pos, xPosForVerticalArrowNavigation(EXTENT));

        break;

    case SentenceBoundary:

        pos = endOfSentence(endForPlatform());

        break;

    case LineBoundary:

        pos = endForPlatform();

        pos.setAffinity(UPSTREAM);

        pos = logicalEndOfLine(pos);

        break;

    case ParagraphBoundary:

        pos = endOfParagraph(endForPlatform());

        break;

    case DocumentBoundary:

        pos = endForPlatform();

        if (isEditablePosition(pos.deepEquivalent()))

            pos = endOfEditableContent(pos);

        else

            pos = endOfDocument(pos);

        break;

    }

    return pos;

}

VisiblePosition SelectionController::modifyMovingRight(TextGranularity granularity)

{

    VisiblePosition pos;

    switch (granularity) {

    case CharacterGranularity:

        if (isRange())

            pos = VisiblePosition(m_selection.end(), m_selection.affinity());

        else

            pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).right(true);

        break;

    case WordGranularity:

    case SentenceGranularity:

    case LineGranularity:

    case ParagraphGranularity:

    case SentenceBoundary:

    case LineBoundary:

    case ParagraphBoundary:

    case DocumentBoundary:

        // FIXME: Implement all of the above.

        pos = modifyMovingForward(granularity);

        break;

    }

    return pos;

}

VisiblePosition SelectionController::modifyMovingForward(TextGranularity granularity)

{

    VisiblePosition pos;

    // FIXME: Stay in editable content for the less common granularities.

    switch (granularity) {

    case CharacterGranularity:

        if (isRange())

            pos = VisiblePosition(m_selection.end(), m_selection.affinity());

        else

            pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).next(true);

        break;

    case WordGranularity:

        pos = nextWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));

        break;

    case SentenceGranularity:

        pos = nextSentencePosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));

        break;

    case LineGranularity: {

        // down-arrowing from a range selection that ends at the start of a line needs

        // to leave the selection at that line start (no need to call nextLinePosition!)

        pos = endForPlatform();

        if (!isRange() || !isStartOfLine(pos))

            pos = nextLinePosition(pos, xPosForVerticalArrowNavigation(START));

        break;

    }

    case ParagraphGranularity:

        pos = nextParagraphPosition(endForPlatform(), xPosForVerticalArrowNavigation(START));

        break;

    case SentenceBoundary:

        pos = endOfSentence(endForPlatform());

        break;

    case LineBoundary:

        pos = logicalEndOfLine(endForPlatform());

        break;

    case ParagraphBoundary:

        pos = endOfParagraph(endForPlatform());

        break;

    case DocumentBoundary:

        pos = endForPlatform();

        if (isEditablePosition(pos.deepEquivalent()))

            pos = endOfEditableContent(pos);

        else

            pos = endOfDocument(pos);

        break;

    }

    return pos;

}

VisiblePosition SelectionController::modifyExtendingLeft(TextGranularity granularity)

{

    VisiblePosition pos(m_selection.extent(), m_selection.affinity());

    // The difference between modifyExtendingLeft and modifyExtendingBackward is:

    // modifyExtendingBackward always extends backward logically.

    // modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,

    // it extends backward logically if the enclosing block is LTR direction,

    // but it extends forward logically if the enclosing block is RTL direction.

    switch (granularity) {

    case CharacterGranularity:

        if (directionOfEnclosingBlock() == LTR)

            pos = pos.previous(true);

        else

            pos = pos.next(true);

        break;

    case WordGranularity:

        if (directionOfEnclosingBlock() == LTR)

            pos = previousWordPosition(pos);

        else

            pos = nextWordPosition(pos);

        break;

    case SentenceGranularity:

    case LineGranularity:

    case ParagraphGranularity:

    case SentenceBoundary:

    case LineBoundary:

    case ParagraphBoundary:

    case DocumentBoundary:

        pos = modifyExtendingBackward(granularity);

    }

    return pos;

}

VisiblePosition SelectionController::modifyExtendingBackward(TextGranularity granularity)

{

    VisiblePosition pos(m_selection.extent(), m_selection.affinity());

    // Extending a selection backward by word or character from just after a table selects

    // the table.  This "makes sense" from the user perspective, esp. when deleting.

    // It was done here instead of in VisiblePosition because we want VPs to iterate

    // over everything.

    switch (granularity) {

    case CharacterGranularity:

        pos = pos.previous(true);

        break;

    case WordGranularity:

        pos = previousWordPosition(pos);

        break;

    case SentenceGranularity:

        pos = previousSentencePosition(pos);

        break;

    case LineGranularity:

        pos = previousLinePosition(pos, xPosForVerticalArrowNavigation(EXTENT));