| /* |
| * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. |
| * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org) |
| * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies) |
| * Copyright (C) 2015 Google 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 "core/editing/SelectionController.h" |
| |
| #include "core/HTMLNames.h" |
| #include "core/dom/Document.h" |
| #include "core/editing/EditingUtilities.h" |
| #include "core/editing/Editor.h" |
| #include "core/editing/FrameSelection.h" |
| #include "core/editing/iterators/TextIterator.h" |
| #include "core/editing/markers/DocumentMarkerController.h" |
| #include "core/events/Event.h" |
| #include "core/frame/FrameView.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/frame/Settings.h" |
| #include "core/layout/LayoutView.h" |
| #include "core/page/FocusController.h" |
| #include "core/page/Page.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| |
| namespace blink { |
| PassOwnPtrWillBeRawPtr<SelectionController> SelectionController::create(LocalFrame& frame) |
| { |
| return adoptPtrWillBeNoop(new SelectionController(frame)); |
| } |
| |
| SelectionController::SelectionController(LocalFrame& frame) |
| : m_frame(&frame) |
| , m_mouseDownMayStartSelect(false) |
| , m_mouseDownWasSingleClickInSelection(false) |
| , m_mouseDownAllowsMultiClick(false) |
| , m_selectionState(SelectionState::HaveNotStartedSelection) |
| { |
| } |
| |
| DEFINE_TRACE(SelectionController) |
| { |
| visitor->trace(m_frame); |
| } |
| |
| namespace { |
| |
| void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelectionInFlatTree& newSelection) |
| { |
| if (selection.visibleSelection<EditingInFlatTreeStrategy>() == newSelection) |
| return; |
| selection.setSelection(newSelection); |
| } |
| |
| DispatchEventResult dispatchSelectStart(Node* node) |
| { |
| if (!node || !node->layoutObject()) |
| return DispatchEventResult::NotCanceled; |
| |
| return node->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart)); |
| } |
| |
| VisibleSelectionInFlatTree expandSelectionToRespectUserSelectAll(Node* targetNode, const VisibleSelectionInFlatTree& selection) |
| { |
| Node* rootUserSelectAll = EditingInFlatTreeStrategy::rootUserSelectAllForNode(targetNode); |
| if (!rootUserSelectAll) |
| return selection; |
| |
| VisibleSelectionInFlatTree newSelection(selection); |
| newSelection.setBase(mostBackwardCaretPosition(PositionInFlatTree::beforeNode(rootUserSelectAll), CanCrossEditingBoundary)); |
| newSelection.setExtent(mostForwardCaretPosition(PositionInFlatTree::afterNode(rootUserSelectAll), CanCrossEditingBoundary)); |
| |
| return newSelection; |
| } |
| |
| static int textDistance(const PositionInFlatTree& start, const PositionInFlatTree& end) |
| { |
| return TextIteratorInFlatTree::rangeLength(start, end, true); |
| } |
| |
| bool canMouseDownStartSelect(Node* node) |
| { |
| if (!node || !node->layoutObject()) |
| return true; |
| |
| if (!node->canStartSelection()) |
| return false; |
| |
| return true; |
| } |
| |
| VisiblePositionInFlatTree visiblePositionOfHitTestResult(const HitTestResult& hitTestResult) |
| { |
| return createVisiblePosition( |
| fromPositionInDOMTree<EditingInFlatTreeStrategy>(hitTestResult.innerNode()->layoutObject()->positionForPoint(hitTestResult.localPoint()))); |
| } |
| |
| } // namespace |
| |
| bool SelectionController::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event) |
| { |
| TRACE_EVENT0("blink", "SelectionController::handleMousePressEventSingleClick"); |
| |
| m_frame->document()->updateLayoutIgnorePendingStylesheets(); |
| Node* innerNode = event.innerNode(); |
| if (!(innerNode && innerNode->layoutObject() && 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()) { |
| LayoutPoint vPoint = view->rootFrameToContents(event.event().position()); |
| if (!extendSelection && selection().contains(vPoint)) { |
| m_mouseDownWasSingleClickInSelection = true; |
| return false; |
| } |
| } |
| |
| VisiblePositionInFlatTree visiblePos = visiblePositionOfHitTestResult(event.hitTestResult()); |
| if (visiblePos.isNull()) |
| visiblePos = createVisiblePosition(PositionInFlatTree::firstPositionInOrBeforeNode(innerNode)); |
| PositionInFlatTree pos = visiblePos.deepEquivalent(); |
| |
| VisibleSelectionInFlatTree newSelection = selection().visibleSelection<EditingInFlatTreeStrategy>(); |
| TextGranularity granularity = CharacterGranularity; |
| |
| if (extendSelection && newSelection.isCaretOrRange()) { |
| const VisibleSelectionInFlatTree selectionInUserSelectAll(expandSelectionToRespectUserSelectAll(innerNode, VisibleSelectionInFlatTree(createVisiblePosition(pos)))); |
| if (selectionInUserSelectAll.isRange()) { |
| if (selectionInUserSelectAll.start().compareTo(newSelection.start()) < 0) |
| pos = selectionInUserSelectAll.start(); |
| else if (newSelection.end().compareTo(selectionInUserSelectAll.end()) < 0) |
| pos = selectionInUserSelectAll.end(); |
| } |
| |
| if (!m_frame->editor().behavior().shouldConsiderSelectionAsDirectional()) { |
| if (pos.isNotNull()) { |
| // See <rdar://problem/3668157> REGRESSION (Mail): shift-click |
| // deselects when selection was created right-to-left |
| const PositionInFlatTree start = newSelection.start(); |
| const PositionInFlatTree end = newSelection.end(); |
| int distanceToStart = textDistance(start, pos); |
| int distanceToEnd = textDistance(pos, end); |
| if (distanceToStart <= distanceToEnd) |
| newSelection = VisibleSelectionInFlatTree(end, pos); |
| else |
| newSelection = VisibleSelectionInFlatTree(start, pos); |
| } |
| } else { |
| newSelection.setExtent(pos); |
| } |
| |
| if (selection().granularity() != CharacterGranularity) { |
| granularity = selection().granularity(); |
| newSelection.expandUsingGranularity(selection().granularity()); |
| } |
| } else if (m_selectionState != SelectionState::ExtendedSelection) { |
| newSelection = expandSelectionToRespectUserSelectAll(innerNode, VisibleSelectionInFlatTree(visiblePos)); |
| } |
| |
| // Updating the selection is considered side-effect of the event and so it doesn't impact the handled state. |
| updateSelectionForMouseDownDispatchingSelectStart(innerNode, newSelection, granularity); |
| return false; |
| } |
| |
| void SelectionController::updateSelectionForMouseDrag(const HitTestResult& hitTestResult, Node* mousePressNode, const LayoutPoint& dragStartPos, const IntPoint& lastKnownMousePosition) |
| { |
| if (!m_mouseDownMayStartSelect) |
| return; |
| |
| Node* target = hitTestResult.innerNode(); |
| if (!target) |
| return; |
| |
| PositionWithAffinity rawTargetPosition = selection().selection().positionRespectingEditingBoundary(hitTestResult.localPoint(), target); |
| VisiblePositionInFlatTree targetPosition = createVisiblePosition(fromPositionInDOMTree<EditingInFlatTreeStrategy>(rawTargetPosition)); |
| // 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. |
| VisibleSelectionInFlatTree newSelection = selection().visibleSelection<EditingInFlatTreeStrategy>(); |
| |
| // 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().anchorNode()) { |
| if (LayoutObject* selectionBaseLayoutObject = selectionBaseNode->layoutObject()) { |
| if (selectionBaseLayoutObject->isSVGText()) { |
| if (target->layoutObject()->containingBlock() != selectionBaseLayoutObject->containingBlock()) |
| return; |
| } |
| } |
| } |
| |
| if (m_selectionState == SelectionState::HaveNotStartedSelection && dispatchSelectStart(target) != DispatchEventResult::NotCanceled) |
| return; |
| |
| // TODO(yosin) We should check |mousePressNode|, |targetPosition|, and |
| // |newSelection| are valid for |m_frame->document()|. |
| // |dispatchSelectStart()| can change them by "selectstart" event handler. |
| |
| if (m_selectionState != SelectionState::ExtendedSelection) { |
| // Always extend selection here because it's caused by a mouse drag |
| m_selectionState = SelectionState::ExtendedSelection; |
| newSelection = VisibleSelectionInFlatTree(targetPosition); |
| } |
| |
| if (RuntimeEnabledFeatures::userSelectAllEnabled()) { |
| // TODO(yosin) Should we use |Strategy::rootUserSelectAllForNode()|? |
| Node* rootUserSelectAllForMousePressNode = EditingInFlatTreeStrategy::rootUserSelectAllForNode(mousePressNode); |
| if (rootUserSelectAllForMousePressNode && rootUserSelectAllForMousePressNode == EditingInFlatTreeStrategy::rootUserSelectAllForNode(target)) { |
| newSelection.setBase(mostBackwardCaretPosition(PositionInFlatTree::beforeNode(rootUserSelectAllForMousePressNode), CanCrossEditingBoundary)); |
| newSelection.setExtent(mostForwardCaretPosition(PositionInFlatTree::afterNode(rootUserSelectAllForMousePressNode), CanCrossEditingBoundary)); |
| } else { |
| // Reset base for user select all when base is inside user-select-all area and extent < base. |
| if (rootUserSelectAllForMousePressNode) { |
| PositionInFlatTree eventPosition = toPositionInFlatTree(target->layoutObject()->positionForPoint(hitTestResult.localPoint()).position()); |
| PositionInFlatTree dragStartPosition = toPositionInFlatTree(mousePressNode->layoutObject()->positionForPoint(dragStartPos).position()); |
| if (eventPosition.compareTo(dragStartPosition) < 0) |
| newSelection.setBase(mostForwardCaretPosition(PositionInFlatTree::afterNode(rootUserSelectAllForMousePressNode), CanCrossEditingBoundary)); |
| } |
| |
| Node* rootUserSelectAllForTarget = EditingInFlatTreeStrategy::rootUserSelectAllForNode(target); |
| if (rootUserSelectAllForTarget && mousePressNode->layoutObject() && toPositionInFlatTree(target->layoutObject()->positionForPoint(hitTestResult.localPoint()).position()).compareTo(toPositionInFlatTree(mousePressNode->layoutObject()->positionForPoint(dragStartPos).position())) < 0) |
| newSelection.setExtent(mostBackwardCaretPosition(PositionInFlatTree::beforeNode(rootUserSelectAllForTarget), CanCrossEditingBoundary)); |
| else if (rootUserSelectAllForTarget && mousePressNode->layoutObject()) |
| newSelection.setExtent(mostForwardCaretPosition(PositionInFlatTree::afterNode(rootUserSelectAllForTarget), CanCrossEditingBoundary)); |
| else |
| newSelection.setExtent(targetPosition); |
| } |
| } else { |
| newSelection.setExtent(targetPosition); |
| } |
| |
| if (selection().granularity() != CharacterGranularity) |
| newSelection.expandUsingGranularity(selection().granularity()); |
| |
| selection().setNonDirectionalSelectionIfNeeded(newSelection, selection().granularity(), |
| FrameSelection::AdjustEndpointsAtBidiBoundary); |
| } |
| |
| bool SelectionController::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelectionInFlatTree& selection, TextGranularity granularity) |
| { |
| if (targetNode && targetNode->layoutObject() && !targetNode->layoutObject()->isSelectable()) |
| return false; |
| |
| if (dispatchSelectStart(targetNode) != DispatchEventResult::NotCanceled) |
| return false; |
| |
| if (!selection.isValidFor(*m_frame->document())) |
| return false; |
| |
| if (selection.isRange()) { |
| m_selectionState = SelectionState::ExtendedSelection; |
| } else { |
| granularity = CharacterGranularity; |
| m_selectionState = SelectionState::PlacedCaret; |
| } |
| |
| this->selection().setNonDirectionalSelectionIfNeeded(selection, granularity); |
| |
| return true; |
| } |
| |
| void SelectionController::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace) |
| { |
| Node* innerNode = result.innerNode(); |
| VisibleSelectionInFlatTree newSelection; |
| |
| if (!innerNode || !innerNode->layoutObject()) |
| return; |
| |
| const VisiblePositionInFlatTree& pos = visiblePositionOfHitTestResult(result); |
| if (pos.isNotNull()) { |
| newSelection = VisibleSelectionInFlatTree(pos); |
| newSelection.expandUsingGranularity(WordGranularity); |
| } |
| |
| #if OS(ANDROID) |
| // If node doesn't have text except space, tab or line break, do not |
| // select that 'empty' area. |
| EphemeralRangeInFlatTree range = EphemeralRangeInFlatTree(newSelection.start(), newSelection.end()); |
| const String& str = plainText(range, TextIteratorDefaultBehavior); |
| if (str.isEmpty() || str.simplifyWhiteSpace().containsOnlyWhitespace()) |
| return; |
| #endif |
| |
| if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange()) |
| newSelection.appendTrailingWhitespace(); |
| |
| updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity); |
| } |
| |
| void SelectionController::selectClosestMisspellingFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace) |
| { |
| Node* innerNode = result.innerNode(); |
| VisibleSelectionInFlatTree newSelection; |
| |
| if (!innerNode || !innerNode->layoutObject()) |
| return; |
| |
| const VisiblePositionInFlatTree& pos = visiblePositionOfHitTestResult(result); |
| if (pos.isNotNull()) { |
| const PositionInFlatTree& markerPosition = pos.deepEquivalent().parentAnchoredEquivalent(); |
| DocumentMarkerVector markers = innerNode->document().markers().markersInRange(EphemeralRange(toPositionInDOMTree(markerPosition)), DocumentMarker::MisspellingMarkers()); |
| if (markers.size() == 1) { |
| Node* containerNode = markerPosition.computeContainerNode(); |
| const PositionInFlatTree start(containerNode, markers[0]->startOffset()); |
| const PositionInFlatTree end(containerNode, markers[0]->endOffset()); |
| newSelection = VisibleSelectionInFlatTree(start, end); |
| } |
| } |
| |
| if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange()) |
| newSelection.appendTrailingWhitespace(); |
| |
| updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity); |
| } |
| |
| void SelectionController::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result) |
| { |
| if (!m_mouseDownMayStartSelect) |
| return; |
| |
| AppendTrailingWhitespace appendTrailingWhitespace = (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend; |
| |
| return selectClosestWordFromHitTestResult(result.hitTestResult(), appendTrailingWhitespace); |
| } |
| |
| void SelectionController::selectClosestMisspellingFromMouseEvent(const MouseEventWithHitTestResults& result) |
| { |
| if (!m_mouseDownMayStartSelect) |
| return; |
| |
| selectClosestMisspellingFromHitTestResult(result.hitTestResult(), |
| (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend); |
| |
| } |
| |
| void SelectionController::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result) |
| { |
| if (!result.hitTestResult().isLiveLink()) |
| return selectClosestWordFromMouseEvent(result); |
| |
| Node* innerNode = result.innerNode(); |
| |
| if (!innerNode || !innerNode->layoutObject() || !m_mouseDownMayStartSelect) |
| return; |
| |
| VisibleSelectionInFlatTree newSelection; |
| Element* URLElement = result.hitTestResult().URLElement(); |
| const VisiblePositionInFlatTree pos = visiblePositionOfHitTestResult(result.hitTestResult()); |
| if (pos.isNotNull() && pos.deepEquivalent().anchorNode()->isDescendantOf(URLElement)) |
| newSelection = VisibleSelectionInFlatTree::selectionFromContentsOfNode(URLElement); |
| |
| updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity); |
| } |
| |
| bool SelectionController::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event) |
| { |
| TRACE_EVENT0("blink", "SelectionController::handleMousePressEventDoubleClick"); |
| |
| if (!m_mouseDownAllowsMultiClick) |
| return handleMousePressEventSingleClick(event); |
| |
| if (event.event().button() != LeftButton) |
| return false; |
| |
| if (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_selectionState = SelectionState::ExtendedSelection; |
| } else { |
| selectClosestWordFromMouseEvent(event); |
| } |
| return true; |
| } |
| |
| bool SelectionController::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event) |
| { |
| TRACE_EVENT0("blink", "SelectionController::handleMousePressEventTripleClick"); |
| |
| if (!m_mouseDownAllowsMultiClick) |
| return handleMousePressEventSingleClick(event); |
| |
| if (event.event().button() != LeftButton) |
| return false; |
| |
| Node* innerNode = event.innerNode(); |
| if (!(innerNode && innerNode->layoutObject() && m_mouseDownMayStartSelect)) |
| return false; |
| |
| VisibleSelectionInFlatTree newSelection; |
| const VisiblePositionInFlatTree& pos = visiblePositionOfHitTestResult(event.hitTestResult()); |
| if (pos.isNotNull()) { |
| newSelection = VisibleSelectionInFlatTree(pos); |
| newSelection.expandUsingGranularity(ParagraphGranularity); |
| } |
| |
| return updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), ParagraphGranularity); |
| } |
| |
| void SelectionController::handleMousePressEvent(const MouseEventWithHitTestResults& event) |
| { |
| // If we got the event back, that must mean it wasn't prevented, |
| // so it's allowed to start a drag or selection if it wasn't in a scrollbar. |
| m_mouseDownMayStartSelect = (canMouseDownStartSelect(event.innerNode()) || isLinkSelection(event)) |
| && !event.scrollbar(); |
| m_mouseDownWasSingleClickInSelection = false; |
| // Avoid double-tap touch gesture confusion by restricting multi-click side |
| // effects, e.g., word selection, to editable regions. |
| m_mouseDownAllowsMultiClick = !event.event().fromTouch() || selection().hasEditableStyle(); |
| } |
| |
| void SelectionController::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event, const IntPoint& mouseDownPos, const LayoutPoint& dragStartPos, Node* mousePressNode, const IntPoint& lastKnownMousePosition) |
| { |
| if (m_selectionState != SelectionState::ExtendedSelection) { |
| HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active); |
| HitTestResult result(request, mouseDownPos); |
| m_frame->document()->layoutView()->hitTest(result); |
| |
| updateSelectionForMouseDrag(result, mousePressNode, dragStartPos, lastKnownMousePosition); |
| } |
| updateSelectionForMouseDrag(event.hitTestResult(), mousePressNode, dragStartPos, lastKnownMousePosition); |
| } |
| |
| void SelectionController::updateSelectionForMouseDrag(Node* mousePressNode, const LayoutPoint& dragStartPos, const IntPoint& lastKnownMousePosition) |
| { |
| FrameView* view = m_frame->view(); |
| if (!view) |
| return; |
| LayoutView* layoutObject = m_frame->contentLayoutObject(); |
| if (!layoutObject) |
| return; |
| |
| HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::Move); |
| HitTestResult result(request, view->rootFrameToContents(lastKnownMousePosition)); |
| layoutObject->hitTest(result); |
| updateSelectionForMouseDrag(result, mousePressNode, dragStartPos, lastKnownMousePosition); |
| } |
| |
| bool SelectionController::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event, const LayoutPoint& dragStartPos) |
| { |
| bool handled = false; |
| m_mouseDownMayStartSelect = false; |
| // Clear the selection if the mouse didn't move after the last mouse |
| // press and it's not a context menu click. 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_selectionState != SelectionState::ExtendedSelection |
| && dragStartPos == event.event().position() |
| && selection().isRange() |
| && event.event().button() != RightButton) { |
| VisibleSelectionInFlatTree newSelection; |
| Node* node = event.innerNode(); |
| bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled(); |
| if (node && node->layoutObject() && (caretBrowsing || node->hasEditableStyle())) { |
| const VisiblePositionInFlatTree pos = visiblePositionOfHitTestResult(event.hitTestResult()); |
| newSelection = VisibleSelectionInFlatTree(pos); |
| } |
| |
| setSelectionIfNeeded(selection(), newSelection); |
| |
| handled = true; |
| } |
| |
| selection().notifyLayoutObjectOfSelectionChange(UserTriggered); |
| |
| selection().selectFrameElementInParentIfFullySelected(); |
| |
| if (event.event().button() == MiddleButton && !event.isOverLink()) { |
| // Ignore handled, since we want to paste to where the caret was placed anyway. |
| handled = handlePasteGlobalSelection(event.event()) || handled; |
| } |
| |
| return handled; |
| } |
| |
| bool SelectionController::handlePasteGlobalSelection(const PlatformMouseEvent& mouseEvent) |
| { |
| // If the event was a middle click, attempt to copy global selection in after |
| // the newly set caret position. |
| // |
| // This code is called from either the mouse up or mouse down handling. There |
| // is some debate about when the global selection is pasted: |
| // xterm: pastes on up. |
| // GTK: pastes on down. |
| // Qt: pastes on up. |
| // Firefox: pastes on up. |
| // Chromium: pastes on up. |
| // |
| // There is something of a webcompat angle to this well, as highlighted by |
| // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on |
| // down then the text is pasted just before the onclick handler runs and |
| // clears the text box. So it's important this happens after the event |
| // handlers have been fired. |
| if (mouseEvent.type() != PlatformEvent::MouseReleased) |
| return false; |
| |
| if (!m_frame->page()) |
| return false; |
| Frame* focusFrame = m_frame->page()->focusController().focusedOrMainFrame(); |
| // Do not paste here if the focus was moved somewhere else. |
| if (m_frame == focusFrame && m_frame->editor().behavior().supportsGlobalSelection()) |
| return m_frame->editor().createCommand("PasteGlobalSelection").execute(); |
| |
| return false; |
| } |
| |
| bool SelectionController::handleGestureLongPress(const PlatformGestureEvent& gestureEvent, const HitTestResult& hitTestResult) |
| { |
| if (hitTestResult.isLiveLink()) |
| return false; |
| |
| Node* innerNode = hitTestResult.innerNode(); |
| #if OS(ANDROID) |
| bool innerNodeIsSelectable = innerNode && (innerNode->isContentEditable() || innerNode->isTextNode() || innerNode->canStartSelection()); |
| #else |
| bool innerNodeIsSelectable = innerNode && (innerNode->isContentEditable() || innerNode->isTextNode()); |
| #endif |
| if (!innerNodeIsSelectable) |
| return false; |
| |
| selectClosestWordFromHitTestResult(hitTestResult, AppendTrailingWhitespace::DontAppend); |
| return selection().isRange(); |
| } |
| |
| void SelectionController::sendContextMenuEvent(const MouseEventWithHitTestResults& mev, const LayoutPoint& position) |
| { |
| if (selection().contains(position) |
| || mev.scrollbar() |
| // FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse. |
| // If the selection is non-editable, we do word selection to make it easier to use the contextual menu items |
| // available for text selections. But only if we're above text. |
| || !(selection().isContentEditable() || (mev.innerNode() && mev.innerNode()->isTextNode()))) |
| return; |
| |
| // Context menu events are always allowed to perform a selection. |
| TemporaryChange<bool> mouseDownMayStartSelectChange(m_mouseDownMayStartSelect, true); |
| |
| if (mev.hitTestResult().isMisspelled()) |
| return selectClosestMisspellingFromMouseEvent(mev); |
| |
| if (!m_frame->editor().behavior().shouldSelectOnContextualMenuClick()) |
| return; |
| |
| selectClosestWordOrLinkFromMouseEvent(mev); |
| } |
| |
| void SelectionController::passMousePressEventToSubframe(const MouseEventWithHitTestResults& mev) |
| { |
| // If we're clicking into a frame that is selected, the frame will appear |
| // greyed out even though we're clicking on the selection. This looks |
| // really strange (having the whole frame be greyed out), so we deselect the |
| // selection. |
| IntPoint p = m_frame->view()->rootFrameToContents(mev.event().position()); |
| if (!selection().contains(p)) |
| return; |
| |
| const VisiblePositionInFlatTree& visiblePos = visiblePositionOfHitTestResult(mev.hitTestResult()); |
| VisibleSelectionInFlatTree newSelection(visiblePos); |
| selection().setSelection(newSelection); |
| } |
| |
| void SelectionController::initializeSelectionState() |
| { |
| m_selectionState = SelectionState::HaveNotStartedSelection; |
| } |
| |
| void SelectionController::setMouseDownMayStartSelect(bool mayStartSelect) |
| { |
| m_mouseDownMayStartSelect = mayStartSelect; |
| } |
| |
| bool SelectionController::mouseDownMayStartSelect() const |
| { |
| return m_mouseDownMayStartSelect; |
| } |
| |
| bool SelectionController::mouseDownWasSingleClickInSelection() const |
| { |
| return m_mouseDownWasSingleClickInSelection; |
| } |
| |
| void SelectionController::notifySelectionChanged() |
| { |
| if (selection().getSelectionType() == SelectionType::RangeSelection) |
| m_selectionState = SelectionState::ExtendedSelection; |
| else if (selection().getSelectionType() == SelectionType::CaretSelection) |
| m_selectionState = SelectionState::PlacedCaret; |
| else |
| m_selectionState = SelectionState::HaveNotStartedSelection; |
| } |
| |
| FrameSelection& SelectionController::selection() const |
| { |
| return m_frame->selection(); |
| } |
| |
| bool isLinkSelection(const MouseEventWithHitTestResults& event) |
| { |
| return event.event().altKey() && event.isOverLink(); |
| } |
| |
| } // namespace blink |
