| /* |
| * Copyright (C) 2004, 2008, 2009, 2010, 2014-2015 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 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 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 "FrameSelection.h" |
| |
| #include "AXObjectCache.h" |
| #include "CharacterData.h" |
| #include "DeleteSelectionCommand.h" |
| #include "Document.h" |
| #include "Editing.h" |
| #include "Editor.h" |
| #include "EditorClient.h" |
| #include "Element.h" |
| #include "ElementIterator.h" |
| #include "Event.h" |
| #include "EventNames.h" |
| #include "FloatQuad.h" |
| #include "FocusController.h" |
| #include "Frame.h" |
| #include "FrameTree.h" |
| #include "FrameView.h" |
| #include "GraphicsContext.h" |
| #include "HTMLBodyElement.h" |
| #include "HTMLFormElement.h" |
| #include "HTMLFrameElement.h" |
| #include "HTMLIFrameElement.h" |
| #include "HTMLNames.h" |
| #include "HTMLSelectElement.h" |
| #include "HitTestRequest.h" |
| #include "HitTestResult.h" |
| #include "InlineTextBox.h" |
| #include "Page.h" |
| #include "RenderText.h" |
| #include "RenderTextControl.h" |
| #include "RenderTheme.h" |
| #include "RenderView.h" |
| #include "RenderWidget.h" |
| #include "RenderedPosition.h" |
| #include "Settings.h" |
| #include "SpatialNavigation.h" |
| #include "StyleProperties.h" |
| #include "TypingCommand.h" |
| #include "VisibleUnits.h" |
| #include <stdio.h> |
| #include <wtf/text/CString.h> |
| |
| #if PLATFORM(IOS) |
| #include "Chrome.h" |
| #include "ChromeClient.h" |
| #include "Color.h" |
| #include "RenderLayer.h" |
| #include "RenderObject.h" |
| #include "RenderStyle.h" |
| #endif |
| |
| namespace WebCore { |
| |
| using namespace HTMLNames; |
| |
| static inline LayoutUnit NoXPosForVerticalArrowNavigation() |
| { |
| return LayoutUnit::min(); |
| } |
| |
| CaretBase::CaretBase(CaretVisibility visibility) |
| : m_caretRectNeedsUpdate(true) |
| , m_caretVisibility(visibility) |
| { |
| } |
| |
| DragCaretController::DragCaretController() |
| : CaretBase(Visible) |
| { |
| } |
| |
| bool DragCaretController::isContentRichlyEditable() const |
| { |
| return isRichlyEditablePosition(m_position.deepEquivalent()); |
| } |
| |
| IntRect DragCaretController::caretRectInRootViewCoordinates() const |
| { |
| if (!hasCaret()) |
| return { }; |
| |
| if (auto* document = m_position.deepEquivalent().document()) { |
| if (auto* documentView = document->view()) |
| return documentView->contentsToRootView(m_position.absoluteCaretBounds()); |
| } |
| |
| return { }; |
| } |
| |
| static inline bool shouldAlwaysUseDirectionalSelection(Frame* frame) |
| { |
| return !frame || frame->editor().behavior().shouldConsiderSelectionAsDirectional(); |
| } |
| |
| FrameSelection::FrameSelection(Frame* frame) |
| : m_frame(frame) |
| , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation()) |
| , m_granularity(CharacterGranularity) |
| , m_caretBlinkTimer(*this, &FrameSelection::caretBlinkTimerFired) |
| , m_appearanceUpdateTimer(*this, &FrameSelection::appearanceUpdateTimerFired) |
| , m_caretInsidePositionFixed(false) |
| , m_absCaretBoundsDirty(true) |
| , m_caretPaint(true) |
| , m_isCaretBlinkingSuspended(false) |
| , m_focused(frame && frame->page() && frame->page()->focusController().focusedFrame() == frame) |
| , m_shouldShowBlockCursor(false) |
| , m_pendingSelectionUpdate(false) |
| , m_alwaysAlignCursorOnScrollWhenRevealingSelection(false) |
| #if PLATFORM(IOS) |
| , m_updateAppearanceEnabled(false) |
| , m_caretBlinks(true) |
| #endif |
| { |
| if (shouldAlwaysUseDirectionalSelection(m_frame)) |
| m_selection.setIsDirectional(true); |
| } |
| |
| Element* FrameSelection::rootEditableElementOrDocumentElement() const |
| { |
| Element* selectionRoot = m_selection.rootEditableElement(); |
| return selectionRoot ? selectionRoot : m_frame->document()->documentElement(); |
| } |
| |
| void FrameSelection::moveTo(const VisiblePosition &pos, EUserTriggered userTriggered, CursorAlignOnScroll align) |
| { |
| setSelection(VisibleSelection(pos.deepEquivalent(), pos.deepEquivalent(), pos.affinity(), m_selection.isDirectional()), |
| defaultSetSelectionOptions(userTriggered), AXTextStateChangeIntent(), align); |
| } |
| |
| void FrameSelection::moveTo(const VisiblePosition &base, const VisiblePosition &extent, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::moveTo(const Position &pos, EAffinity affinity, EUserTriggered userTriggered) |
| { |
| setSelection(VisibleSelection(pos, affinity, m_selection.isDirectional()), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::moveTo(const Range* range) |
| { |
| VisibleSelection selection = range ? VisibleSelection(range->startPosition(), range->endPosition()) : VisibleSelection(); |
| setSelection(selection); |
| } |
| |
| void FrameSelection::moveTo(const Position &base, const Position &extent, EAffinity affinity, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(base, extent, affinity, selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::moveWithoutValidationTo(const Position& base, const Position& extent, bool selectionHasDirection, bool shouldSetFocus, SelectionRevealMode revealMode, const AXTextStateChangeIntent& intent) |
| { |
| VisibleSelection newSelection; |
| newSelection.setWithoutValidation(base, extent); |
| newSelection.setIsDirectional(selectionHasDirection); |
| AXTextStateChangeIntent newIntent = intent.type == AXTextStateChangeTypeUnknown ? AXTextStateChangeIntent(AXTextStateChangeTypeSelectionMove, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityUnknown, false }) : intent; |
| SetSelectionOptions options = defaultSetSelectionOptions(); |
| if (!shouldSetFocus) |
| options |= DoNotSetFocus; |
| switch (revealMode) { |
| case SelectionRevealMode::DoNotReveal: |
| break; |
| case SelectionRevealMode::Reveal: |
| options |= RevealSelection; |
| break; |
| case SelectionRevealMode::RevealUpToMainFrame: |
| options |= RevealSelectionUpToMainFrame; |
| break; |
| } |
| setSelection(newSelection, options, newIntent); |
| } |
| |
| void DragCaretController::setCaretPosition(const VisiblePosition& position) |
| { |
| if (Node* node = m_position.deepEquivalent().deprecatedNode()) |
| invalidateCaretRect(node); |
| m_position = position; |
| setCaretRectNeedsUpdate(); |
| Document* document = nullptr; |
| if (Node* node = m_position.deepEquivalent().deprecatedNode()) { |
| invalidateCaretRect(node); |
| document = &node->document(); |
| } |
| if (m_position.isNull() || m_position.isOrphan()) |
| clearCaretRect(); |
| else |
| updateCaretRect(document, m_position); |
| } |
| |
| static void adjustEndpointsAtBidiBoundary(VisiblePosition& visibleBase, VisiblePosition& visibleExtent) |
| { |
| RenderedPosition base(visibleBase); |
| RenderedPosition extent(visibleExtent); |
| |
| if (base.isNull() || extent.isNull() || base.isEquivalent(extent)) |
| return; |
| |
| if (base.atLeftBoundaryOfBidiRun()) { |
| if (!extent.atRightBoundaryOfBidiRun(base.bidiLevelOnRight()) |
| && base.isEquivalent(extent.leftBoundaryOfBidiRun(base.bidiLevelOnRight()))) { |
| visibleBase = base.positionAtLeftBoundaryOfBiDiRun(); |
| return; |
| } |
| return; |
| } |
| |
| if (base.atRightBoundaryOfBidiRun()) { |
| if (!extent.atLeftBoundaryOfBidiRun(base.bidiLevelOnLeft()) |
| && base.isEquivalent(extent.rightBoundaryOfBidiRun(base.bidiLevelOnLeft()))) { |
| visibleBase = base.positionAtRightBoundaryOfBiDiRun(); |
| return; |
| } |
| return; |
| } |
| |
| if (extent.atLeftBoundaryOfBidiRun() && extent.isEquivalent(base.leftBoundaryOfBidiRun(extent.bidiLevelOnRight()))) { |
| visibleExtent = extent.positionAtLeftBoundaryOfBiDiRun(); |
| return; |
| } |
| |
| if (extent.atRightBoundaryOfBidiRun() && extent.isEquivalent(base.rightBoundaryOfBidiRun(extent.bidiLevelOnLeft()))) { |
| visibleExtent = extent.positionAtRightBoundaryOfBiDiRun(); |
| return; |
| } |
| } |
| |
| void FrameSelection::setSelectionByMouseIfDifferent(const VisibleSelection& passedNewSelection, TextGranularity granularity, |
| EndPointsAdjustmentMode endpointsAdjustmentMode) |
| { |
| VisibleSelection newSelection = passedNewSelection; |
| bool isDirectional = shouldAlwaysUseDirectionalSelection(m_frame) || newSelection.isDirectional(); |
| |
| VisiblePosition base = m_originalBase.isNotNull() ? m_originalBase : newSelection.visibleBase(); |
| VisiblePosition newBase = base; |
| VisiblePosition extent = newSelection.visibleExtent(); |
| VisiblePosition newExtent = extent; |
| if (endpointsAdjustmentMode == AdjustEndpointsAtBidiBoundary) |
| adjustEndpointsAtBidiBoundary(newBase, newExtent); |
| |
| if (newBase != base || newExtent != extent) { |
| m_originalBase = base; |
| newSelection.setBase(newBase); |
| newSelection.setExtent(newExtent); |
| } else if (m_originalBase.isNotNull()) { |
| if (m_selection.base() == newSelection.base()) |
| newSelection.setBase(m_originalBase); |
| m_originalBase.clear(); |
| } |
| |
| newSelection.setIsDirectional(isDirectional); // Adjusting base and extent will make newSelection always directional |
| if (m_selection == newSelection || !shouldChangeSelection(newSelection)) |
| return; |
| |
| |
| AXTextStateChangeIntent intent; |
| if (AXObjectCache::accessibilityEnabled() && newSelection.isCaret()) |
| intent = AXTextStateChangeIntent(AXTextStateChangeTypeSelectionMove, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityUnknown, false }); |
| else |
| intent = AXTextStateChangeIntent(); |
| setSelection(newSelection, defaultSetSelectionOptions() | FireSelectEvent, intent, AlignCursorOnScrollIfNeeded, granularity); |
| } |
| |
| bool FrameSelection::setSelectionWithoutUpdatingAppearance(const VisibleSelection& newSelectionPossiblyWithoutDirection, SetSelectionOptions options, CursorAlignOnScroll align, TextGranularity granularity) |
| { |
| bool closeTyping = options & CloseTyping; |
| bool shouldClearTypingStyle = options & ClearTypingStyle; |
| |
| VisibleSelection newSelection = newSelectionPossiblyWithoutDirection; |
| if (shouldAlwaysUseDirectionalSelection(m_frame)) |
| newSelection.setIsDirectional(true); |
| |
| if (!m_frame) { |
| m_selection = newSelection; |
| return false; |
| } |
| |
| // <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at FrameSelection::setSelection |
| // if document->frame() == m_frame we can get into an infinite loop |
| if (Document* newSelectionDocument = newSelection.base().document()) { |
| if (RefPtr<Frame> newSelectionFrame = newSelectionDocument->frame()) { |
| if (newSelectionFrame != m_frame && newSelectionDocument != m_frame->document()) { |
| newSelectionFrame->selection().setSelection(newSelection, options, AXTextStateChangeIntent(), align, granularity); |
| // It's possible that during the above set selection, this FrameSelection has been modified by |
| // selectFrameElementInParentIfFullySelected, but that the selection is no longer valid since |
| // the frame is about to be destroyed. If this is the case, clear our selection. |
| if (newSelectionFrame->hasOneRef() && m_selection.isNoneOrOrphaned()) |
| clear(); |
| return false; |
| } |
| } |
| } |
| |
| m_granularity = granularity; |
| |
| if (closeTyping) |
| TypingCommand::closeTyping(m_frame); |
| |
| if (shouldClearTypingStyle) |
| clearTypingStyle(); |
| |
| VisibleSelection oldSelection = m_selection; |
| bool didMutateSelection = oldSelection != newSelection; |
| if (didMutateSelection) |
| m_frame->editor().selectionWillChange(); |
| |
| m_selection = newSelection; |
| |
| // Selection offsets should increase when LF is inserted before the caret in InsertLineBreakCommand. See <https://webkit.org/b/56061>. |
| if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(newSelection.start())) |
| textControl->selectionChanged(options & FireSelectEvent); |
| |
| if (!didMutateSelection) |
| return false; |
| |
| setCaretRectNeedsUpdate(); |
| |
| if (!newSelection.isNone() && !(options & DoNotSetFocus)) |
| setFocusedElementIfNeeded(); |
| |
| // 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->editor().respondToChangedSelection(oldSelection, options); |
| m_frame->document()->enqueueDocumentEvent(Event::create(eventNames().selectionchangeEvent, false, false)); |
| |
| return true; |
| } |
| |
| void FrameSelection::setSelection(const VisibleSelection& selection, SetSelectionOptions options, AXTextStateChangeIntent intent, CursorAlignOnScroll align, TextGranularity granularity) |
| { |
| RefPtr<Frame> protectedFrame(m_frame); |
| if (!setSelectionWithoutUpdatingAppearance(selection, options, align, granularity)) |
| return; |
| |
| Document* document = m_frame->document(); |
| if (!document) |
| return; |
| |
| if (options & RevealSelectionUpToMainFrame) |
| m_selectionRevealMode = SelectionRevealMode::RevealUpToMainFrame; |
| else if (options & RevealSelection) |
| m_selectionRevealMode = SelectionRevealMode::Reveal; |
| else |
| m_selectionRevealMode = SelectionRevealMode::DoNotReveal; |
| m_alwaysAlignCursorOnScrollWhenRevealingSelection = align == AlignCursorOnScrollAlways; |
| |
| m_selectionRevealIntent = intent; |
| m_pendingSelectionUpdate = true; |
| |
| if (document->hasPendingStyleRecalc()) |
| return; |
| |
| FrameView* frameView = document->view(); |
| if (frameView && frameView->layoutContext().isLayoutPending()) |
| return; |
| |
| updateAndRevealSelection(intent); |
| |
| if (options & IsUserTriggered) { |
| if (auto* client = m_frame->editor().client()) |
| client->didEndUserTriggeredSelectionChanges(); |
| } |
| } |
| |
| static void updateSelectionByUpdatingLayoutOrStyle(Frame& frame) |
| { |
| #if ENABLE(TEXT_CARET) |
| frame.document()->updateLayoutIgnorePendingStylesheets(); |
| #else |
| frame.document()->updateStyleIfNeeded(); |
| #endif |
| } |
| |
| void FrameSelection::setNeedsSelectionUpdate() |
| { |
| m_selectionRevealIntent = AXTextStateChangeIntent(); |
| m_pendingSelectionUpdate = true; |
| if (RenderView* view = m_frame->contentRenderer()) |
| view->selection().clear(); |
| } |
| |
| void FrameSelection::updateAndRevealSelection(const AXTextStateChangeIntent& intent) |
| { |
| if (!m_pendingSelectionUpdate) |
| return; |
| |
| m_pendingSelectionUpdate = false; |
| |
| updateAppearance(); |
| |
| if (m_selectionRevealMode != SelectionRevealMode::DoNotReveal) { |
| ScrollAlignment alignment; |
| |
| if (m_frame->editor().behavior().shouldCenterAlignWhenSelectionIsRevealed()) |
| alignment = m_alwaysAlignCursorOnScrollWhenRevealingSelection ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded; |
| else |
| alignment = m_alwaysAlignCursorOnScrollWhenRevealingSelection ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded; |
| |
| revealSelection(m_selectionRevealMode, alignment, RevealExtent); |
| } |
| |
| notifyAccessibilityForSelectionChange(intent); |
| } |
| |
| void FrameSelection::updateDataDetectorsForSelection() |
| { |
| #if ENABLE(TELEPHONE_NUMBER_DETECTION) && !PLATFORM(IOS) |
| m_frame->editor().scanSelectionForTelephoneNumbers(); |
| #endif |
| } |
| |
| static bool removingNodeRemovesPosition(Node& node, const Position& position) |
| { |
| if (!position.anchorNode()) |
| return false; |
| |
| if (position.anchorNode() == &node) |
| return true; |
| |
| if (!is<Element>(node)) |
| return false; |
| |
| return downcast<Element>(node).containsIncludingShadowDOM(position.anchorNode()); |
| } |
| |
| void DragCaretController::nodeWillBeRemoved(Node& node) |
| { |
| if (!hasCaret() || !node.isConnected()) |
| return; |
| |
| if (!removingNodeRemovesPosition(node, m_position.deepEquivalent())) |
| return; |
| |
| if (RenderView* view = node.document().renderView()) |
| view->selection().clear(); |
| |
| clear(); |
| } |
| |
| void FrameSelection::nodeWillBeRemoved(Node& node) |
| { |
| // 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 (isNone() || !node.isConnected()) |
| return; |
| |
| respondToNodeModification(node, removingNodeRemovesPosition(node, m_selection.base()), removingNodeRemovesPosition(node, m_selection.extent()), |
| removingNodeRemovesPosition(node, m_selection.start()), removingNodeRemovesPosition(node, m_selection.end())); |
| } |
| |
| void FrameSelection::respondToNodeModification(Node& node, bool baseRemoved, bool extentRemoved, bool startRemoved, bool endRemoved) |
| { |
| bool clearRenderTreeSelection = false; |
| bool clearDOMTreeSelection = false; |
| |
| if (startRemoved || endRemoved) { |
| Position start = m_selection.start(); |
| Position end = m_selection.end(); |
| if (startRemoved) |
| updatePositionForNodeRemoval(start, node); |
| if (endRemoved) |
| updatePositionForNodeRemoval(end, node); |
| |
| if (start.isNotNull() && end.isNotNull()) { |
| if (m_selection.isBaseFirst()) |
| m_selection.setWithoutValidation(start, end); |
| else |
| m_selection.setWithoutValidation(end, start); |
| } else |
| clearDOMTreeSelection = true; |
| |
| clearRenderTreeSelection = 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()); |
| } else if (RefPtr<Range> range = m_selection.firstRange()) { |
| auto compareNodeResult = range->compareNode(node); |
| if (!compareNodeResult.hasException()) { |
| auto compareResult = compareNodeResult.releaseReturnValue(); |
| if (compareResult == Range::NODE_BEFORE_AND_AFTER || compareResult == Range::NODE_INSIDE) { |
| // 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) { |
| if (auto* renderView = node.document().renderView()) { |
| renderView->selection().clear(); |
| |
| // Trigger a selection update so the selection will be set again. |
| m_selectionRevealIntent = AXTextStateChangeIntent(); |
| m_pendingSelectionUpdate = true; |
| renderView->frameView().scheduleSelectionUpdate(); |
| } |
| } |
| |
| if (clearDOMTreeSelection) |
| setSelection(VisibleSelection(), DoNotSetFocus); |
| } |
| |
| static void updatePositionAfterAdoptingTextReplacement(Position& position, CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength) |
| { |
| if (!position.anchorNode() || position.anchorNode() != node || position.anchorType() != Position::PositionIsOffsetInAnchor) |
| return; |
| |
| // See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation |
| ASSERT(position.offsetInContainerNode() >= 0); |
| unsigned positionOffset = static_cast<unsigned>(position.offsetInContainerNode()); |
| // Replacing text can be viewed as a deletion followed by insertion. |
| if (positionOffset >= offset && positionOffset <= offset + oldLength) |
| position.moveToOffset(offset); |
| |
| // Adjust the offset if the position is after the end of the deleted contents |
| // (positionOffset > offset + oldLength) to avoid having a stale offset. |
| if (positionOffset > offset + oldLength) |
| position.moveToOffset(positionOffset - oldLength + newLength); |
| |
| ASSERT(static_cast<unsigned>(position.offsetInContainerNode()) <= node->length()); |
| } |
| |
| void FrameSelection::textWasReplaced(CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength) |
| { |
| // The fragment check is a performance optimization. See http://trac.webkit.org/changeset/30062. |
| if (isNone() || !node || !node->isConnected()) |
| return; |
| |
| Position base = m_selection.base(); |
| Position extent = m_selection.extent(); |
| Position start = m_selection.start(); |
| Position end = m_selection.end(); |
| updatePositionAfterAdoptingTextReplacement(base, node, offset, oldLength, newLength); |
| updatePositionAfterAdoptingTextReplacement(extent, node, offset, oldLength, newLength); |
| updatePositionAfterAdoptingTextReplacement(start, node, offset, oldLength, newLength); |
| updatePositionAfterAdoptingTextReplacement(end, node, offset, oldLength, newLength); |
| |
| if (base != m_selection.base() || extent != m_selection.extent() || start != m_selection.start() || end != m_selection.end()) { |
| VisibleSelection newSelection; |
| if (base != extent) |
| newSelection.setWithoutValidation(base, extent); |
| else if (m_selection.isDirectional() && !m_selection.isBaseFirst()) |
| newSelection.setWithoutValidation(end, start); |
| else |
| newSelection.setWithoutValidation(start, end); |
| |
| setSelection(newSelection, DoNotSetFocus); |
| } |
| } |
| |
| TextDirection FrameSelection::directionOfEnclosingBlock() |
| { |
| return WebCore::directionOfEnclosingBlock(m_selection.extent()); |
| } |
| |
| TextDirection FrameSelection::directionOfSelection() |
| { |
| InlineBox* startBox = nullptr; |
| InlineBox* endBox = nullptr; |
| int unusedOffset; |
| // Cache the VisiblePositions because visibleStart() and visibleEnd() |
| // can cause layout, which has the potential to invalidate lineboxes. |
| VisiblePosition startPosition = m_selection.visibleStart(); |
| VisiblePosition endPosition = m_selection.visibleEnd(); |
| if (startPosition.isNotNull()) |
| startPosition.getInlineBoxAndOffset(startBox, unusedOffset); |
| if (endPosition.isNotNull()) |
| endPosition.getInlineBoxAndOffset(endBox, unusedOffset); |
| if (startBox && endBox && startBox->direction() == endBox->direction()) |
| return startBox->direction(); |
| |
| return directionOfEnclosingBlock(); |
| } |
| |
| void FrameSelection::willBeModified(EAlteration alter, SelectionDirection direction) |
| { |
| if (alter != AlterationExtend) |
| return; |
| |
| Position start = m_selection.start(); |
| Position end = m_selection.end(); |
| |
| bool baseIsStart = true; |
| |
| if (m_selection.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()) |
| baseIsStart = true; |
| else |
| baseIsStart = false; |
| } else { |
| switch (direction) { |
| case DirectionRight: |
| if (directionOfSelection() == LTR) |
| baseIsStart = true; |
| else |
| baseIsStart = false; |
| break; |
| case DirectionForward: |
| baseIsStart = true; |
| break; |
| case DirectionLeft: |
| if (directionOfSelection() == LTR) |
| baseIsStart = false; |
| else |
| baseIsStart = true; |
| break; |
| case DirectionBackward: |
| baseIsStart = false; |
| break; |
| } |
| } |
| if (baseIsStart) { |
| m_selection.setBase(start); |
| m_selection.setExtent(end); |
| } else { |
| m_selection.setBase(end); |
| m_selection.setExtent(start); |
| } |
| } |
| |
| VisiblePosition FrameSelection::positionForPlatform(bool isGetStart) const |
| { |
| // 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(). |
| if (m_frame && m_frame->editor().behavior().shouldAlwaysExtendSelectionFromExtentEndpoint()) |
| return m_selection.isBaseFirst() ? m_selection.visibleEnd() : m_selection.visibleStart(); |
| |
| return isGetStart ? m_selection.visibleStart() : m_selection.visibleEnd(); |
| } |
| |
| VisiblePosition FrameSelection::startForPlatform() const |
| { |
| return positionForPlatform(true); |
| } |
| |
| VisiblePosition FrameSelection::endForPlatform() const |
| { |
| return positionForPlatform(false); |
| } |
| |
| VisiblePosition FrameSelection::nextWordPositionForPlatform(const VisiblePosition &originalPosition) |
| { |
| VisiblePosition positionAfterCurrentWord = nextWordPosition(originalPosition); |
| |
| if (m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight()) { |
| // In order to skip spaces when moving right, we advance one |
| // word further and then move one word back. Given the |
| // semantics of previousWordPosition() this will put us at the |
| // beginning of the word following. |
| VisiblePosition positionAfterSpacingAndFollowingWord = nextWordPosition(positionAfterCurrentWord); |
| if (positionAfterSpacingAndFollowingWord != positionAfterCurrentWord) |
| positionAfterCurrentWord = previousWordPosition(positionAfterSpacingAndFollowingWord); |
| |
| bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord == previousWordPosition(nextWordPosition(originalPosition)); |
| if (movingBackwardsMovedPositionToStartOfCurrentWord) |
| positionAfterCurrentWord = positionAfterSpacingAndFollowingWord; |
| } |
| return positionAfterCurrentWord; |
| } |
| |
| #if ENABLE(USERSELECT_ALL) |
| static void adjustPositionForUserSelectAll(VisiblePosition& pos, bool isForward) |
| { |
| if (Node* rootUserSelectAll = Position::rootUserSelectAllForNode(pos.deepEquivalent().anchorNode())) |
| pos = isForward ? positionAfterNode(rootUserSelectAll).downstream(CanCrossEditingBoundary) : positionBeforeNode(rootUserSelectAll).upstream(CanCrossEditingBoundary); |
| } |
| #endif |
| |
| VisiblePosition FrameSelection::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(CannotCrossEditingBoundary); |
| else |
| pos = pos.previous(CannotCrossEditingBoundary); |
| break; |
| case WordGranularity: |
| if (directionOfEnclosingBlock() == LTR) |
| pos = nextWordPositionForPlatform(pos); |
| else |
| pos = previousWordPosition(pos); |
| break; |
| case LineBoundary: |
| if (directionOfEnclosingBlock() == LTR) |
| pos = modifyExtendingForward(granularity); |
| else |
| pos = modifyExtendingBackward(granularity); |
| break; |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| // FIXME: implement all of the above? |
| pos = modifyExtendingForward(granularity); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| #if ENABLE(USERSELECT_ALL) |
| adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR); |
| #endif |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::modifyExtendingForward(TextGranularity granularity) |
| { |
| VisiblePosition pos(m_selection.extent(), m_selection.affinity()); |
| switch (granularity) { |
| case CharacterGranularity: |
| pos = pos.next(CannotCrossEditingBoundary); |
| break; |
| case WordGranularity: |
| pos = nextWordPositionForPlatform(pos); |
| break; |
| case SentenceGranularity: |
| pos = nextSentencePosition(pos); |
| break; |
| case LineGranularity: |
| pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT)); |
| break; |
| case ParagraphGranularity: |
| pos = nextParagraphPosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT)); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| 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; |
| } |
| #if ENABLE(USERSELECT_ALL) |
| adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR); |
| #endif |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::modifyMovingRight(TextGranularity granularity, bool* reachedBoundary) |
| { |
| if (reachedBoundary) |
| *reachedBoundary = false; |
| VisiblePosition pos; |
| switch (granularity) { |
| case CharacterGranularity: |
| if (isRange()) { |
| if (directionOfSelection() == LTR) |
| pos = VisiblePosition(m_selection.end(), m_selection.affinity()); |
| else |
| pos = VisiblePosition(m_selection.start(), m_selection.affinity()); |
| } else |
| pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).right(true, reachedBoundary); |
| break; |
| case WordGranularity: { |
| bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight(); |
| VisiblePosition currentPosition(m_selection.extent(), m_selection.affinity()); |
| pos = rightWordPosition(currentPosition, skipsSpaceWhenMovingRight); |
| if (reachedBoundary) |
| *reachedBoundary = pos == currentPosition; |
| break; |
| } |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| // FIXME: Implement all of the above. |
| pos = modifyMovingForward(granularity, reachedBoundary); |
| break; |
| case LineBoundary: |
| pos = rightBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock(), reachedBoundary); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::modifyMovingForward(TextGranularity granularity, bool* reachedBoundary) |
| { |
| if (reachedBoundary) |
| *reachedBoundary = false; |
| VisiblePosition currentPosition; |
| switch (granularity) { |
| case WordGranularity: |
| case SentenceGranularity: |
| currentPosition = VisiblePosition(m_selection.extent(), m_selection.affinity()); |
| break; |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| currentPosition = endForPlatform(); |
| break; |
| default: |
| break; |
| } |
| 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(CannotCrossEditingBoundary, reachedBoundary); |
| break; |
| case WordGranularity: |
| pos = nextWordPositionForPlatform(currentPosition); |
| break; |
| case SentenceGranularity: |
| pos = nextSentencePosition(currentPosition); |
| 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 = currentPosition; |
| if (!isRange() || !isStartOfLine(pos)) |
| pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(START)); |
| break; |
| } |
| case ParagraphGranularity: |
| pos = nextParagraphPosition(currentPosition, lineDirectionPointForBlockDirectionNavigation(START)); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| case SentenceBoundary: |
| pos = endOfSentence(currentPosition); |
| break; |
| case LineBoundary: |
| pos = logicalEndOfLine(endForPlatform(), reachedBoundary); |
| break; |
| case ParagraphBoundary: |
| pos = endOfParagraph(currentPosition); |
| break; |
| case DocumentBoundary: |
| pos = currentPosition; |
| if (isEditablePosition(pos.deepEquivalent())) |
| pos = endOfEditableContent(pos); |
| else |
| pos = endOfDocument(pos); |
| break; |
| } |
| switch (granularity) { |
| case WordGranularity: |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| if (reachedBoundary) |
| *reachedBoundary = pos == currentPosition; |
| break; |
| default: |
| break; |
| } |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::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(CannotCrossEditingBoundary); |
| else |
| pos = pos.next(CannotCrossEditingBoundary); |
| break; |
| case WordGranularity: |
| if (directionOfEnclosingBlock() == LTR) |
| pos = previousWordPosition(pos); |
| else |
| pos = nextWordPositionForPlatform(pos); |
| break; |
| case LineBoundary: |
| if (directionOfEnclosingBlock() == LTR) |
| pos = modifyExtendingBackward(granularity); |
| else |
| pos = modifyExtendingForward(granularity); |
| break; |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| pos = modifyExtendingBackward(granularity); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| #if ENABLE(USERSELECT_ALL) |
| adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR)); |
| #endif |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::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(CannotCrossEditingBoundary); |
| break; |
| case WordGranularity: |
| pos = previousWordPosition(pos); |
| break; |
| case SentenceGranularity: |
| pos = previousSentencePosition(pos); |
| break; |
| case LineGranularity: |
| pos = previousLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT)); |
| break; |
| case ParagraphGranularity: |
| pos = previousParagraphPosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT)); |
| break; |
| case SentenceBoundary: |
| pos = startOfSentence(startForPlatform()); |
| break; |
| case LineBoundary: |
| pos = logicalStartOfLine(startForPlatform()); |
| break; |
| case ParagraphBoundary: |
| pos = startOfParagraph(startForPlatform()); |
| break; |
| case DocumentBoundary: |
| pos = startForPlatform(); |
| if (isEditablePosition(pos.deepEquivalent())) |
| pos = startOfEditableContent(pos); |
| else |
| pos = startOfDocument(pos); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| #if ENABLE(USERSELECT_ALL) |
| adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR)); |
| #endif |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::modifyMovingLeft(TextGranularity granularity, bool* reachedBoundary) |
| { |
| if (reachedBoundary) |
| *reachedBoundary = false; |
| VisiblePosition pos; |
| switch (granularity) { |
| case CharacterGranularity: |
| if (isRange()) |
| if (directionOfSelection() == LTR) |
| pos = VisiblePosition(m_selection.start(), m_selection.affinity()); |
| else |
| pos = VisiblePosition(m_selection.end(), m_selection.affinity()); |
| else |
| pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).left(true, reachedBoundary); |
| break; |
| case WordGranularity: { |
| bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight(); |
| VisiblePosition currentPosition(m_selection.extent(), m_selection.affinity()); |
| pos = leftWordPosition(currentPosition, skipsSpaceWhenMovingRight); |
| if (reachedBoundary) |
| *reachedBoundary = pos == currentPosition; |
| break; |
| } |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| // FIXME: Implement all of the above. |
| pos = modifyMovingBackward(granularity, reachedBoundary); |
| break; |
| case LineBoundary: |
| pos = leftBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock(), reachedBoundary); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| return pos; |
| } |
| |
| VisiblePosition FrameSelection::modifyMovingBackward(TextGranularity granularity, bool* reachedBoundary) |
| { |
| if (reachedBoundary) |
| *reachedBoundary = false; |
| VisiblePosition currentPosition; |
| switch (granularity) { |
| case WordGranularity: |
| case SentenceGranularity: |
| currentPosition = VisiblePosition(m_selection.extent(), m_selection.affinity()); |
| break; |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| currentPosition = startForPlatform(); |
| break; |
| default: |
| break; |
| } |
| VisiblePosition pos; |
| switch (granularity) { |
| case CharacterGranularity: |
| if (isRange()) |
| pos = VisiblePosition(m_selection.start(), m_selection.affinity()); |
| else |
| pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).previous(CannotCrossEditingBoundary, reachedBoundary); |
| break; |
| case WordGranularity: |
| pos = previousWordPosition(currentPosition); |
| break; |
| case SentenceGranularity: |
| pos = previousSentencePosition(currentPosition); |
| break; |
| case LineGranularity: |
| pos = previousLinePosition(currentPosition, lineDirectionPointForBlockDirectionNavigation(START)); |
| break; |
| case ParagraphGranularity: |
| pos = previousParagraphPosition(currentPosition, lineDirectionPointForBlockDirectionNavigation(START)); |
| break; |
| case SentenceBoundary: |
| pos = startOfSentence(currentPosition); |
| break; |
| case LineBoundary: |
| pos = logicalStartOfLine(startForPlatform(), reachedBoundary); |
| break; |
| case ParagraphBoundary: |
| pos = startOfParagraph(currentPosition); |
| break; |
| case DocumentBoundary: |
| pos = currentPosition; |
| if (isEditablePosition(pos.deepEquivalent())) |
| pos = startOfEditableContent(pos); |
| else |
| pos = startOfDocument(pos); |
| break; |
| case DocumentGranularity: |
| ASSERT_NOT_REACHED(); |
| break; |
| } |
| switch (granularity) { |
| case WordGranularity: |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case SentenceBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| if (reachedBoundary) |
| *reachedBoundary = pos == currentPosition; |
| break; |
| default: |
| break; |
| } |
| return pos; |
| } |
| |
| static bool isBoundary(TextGranularity granularity) |
| { |
| return granularity == LineBoundary || granularity == ParagraphBoundary || granularity == DocumentBoundary; |
| } |
| |
| AXTextStateChangeIntent FrameSelection::textSelectionIntent(EAlteration alter, SelectionDirection direction, TextGranularity granularity) |
| { |
| AXTextStateChangeIntent intent = AXTextStateChangeIntent(); |
| bool flip = false; |
| if (alter == FrameSelection::AlterationMove) { |
| intent.type = AXTextStateChangeTypeSelectionMove; |
| flip = isRange() && directionOfSelection() == RTL; |
| } else |
| intent.type = AXTextStateChangeTypeSelectionExtend; |
| switch (granularity) { |
| case CharacterGranularity: |
| intent.selection.granularity = AXTextSelectionGranularityCharacter; |
| break; |
| case WordGranularity: |
| intent.selection.granularity = AXTextSelectionGranularityWord; |
| break; |
| case SentenceGranularity: |
| case SentenceBoundary: |
| intent.selection.granularity = AXTextSelectionGranularitySentence; |
| break; |
| case LineGranularity: |
| case LineBoundary: |
| intent.selection.granularity = AXTextSelectionGranularityLine; |
| break; |
| case ParagraphGranularity: |
| case ParagraphBoundary: |
| intent.selection.granularity = AXTextSelectionGranularityParagraph; |
| break; |
| case DocumentGranularity: |
| case DocumentBoundary: |
| intent.selection.granularity = AXTextSelectionGranularityDocument; |
| break; |
| } |
| bool boundary = false; |
| switch (granularity) { |
| case CharacterGranularity: |
| case WordGranularity: |
| case SentenceGranularity: |
| case LineGranularity: |
| case ParagraphGranularity: |
| case DocumentGranularity: |
| break; |
| case SentenceBoundary: |
| case LineBoundary: |
| case ParagraphBoundary: |
| case DocumentBoundary: |
| boundary = true; |
| break; |
| } |
| switch (direction) { |
| case DirectionRight: |
| case DirectionForward: |
| if (boundary) |
| intent.selection.direction = flip ? AXTextSelectionDirectionBeginning : AXTextSelectionDirectionEnd; |
| else |
| intent.selection.direction = flip ? AXTextSelectionDirectionPrevious : AXTextSelectionDirectionNext; |
| break; |
| case DirectionLeft: |
| case DirectionBackward: |
| if (boundary) |
| intent.selection.direction = flip ? AXTextSelectionDirectionEnd : AXTextSelectionDirectionBeginning; |
| else |
| intent.selection.direction = flip ? AXTextSelectionDirectionNext : AXTextSelectionDirectionPrevious; |
| break; |
| } |
| return intent; |
| } |
| |
| static AXTextSelection textSelectionWithDirectionAndGranularity(SelectionDirection direction, TextGranularity granularity) |
| { |
| // FIXME: Account for BIDI in DirectionRight & DirectionLeft. (In a RTL block, Right would map to Previous/Beginning and Left to Next/End.) |
| AXTextSelectionDirection intentDirection = AXTextSelectionDirectionUnknown; |
| switch (direction) { |
| case DirectionForward: |
| intentDirection = AXTextSelectionDirectionNext; |
| break; |
| case DirectionRight: |
| intentDirection = AXTextSelectionDirectionNext; |
| break; |
| case DirectionBackward: |
| intentDirection = AXTextSelectionDirectionPrevious; |
| break; |
| case DirectionLeft: |
| intentDirection = AXTextSelectionDirectionPrevious; |
| break; |
| } |
| AXTextSelectionGranularity intentGranularity = AXTextSelectionGranularityUnknown; |
| switch (granularity) { |
| case CharacterGranularity: |
| intentGranularity = AXTextSelectionGranularityCharacter; |
| break; |
| case WordGranularity: |
| intentGranularity = AXTextSelectionGranularityWord; |
| break; |
| case SentenceGranularity: |
| case SentenceBoundary: // FIXME: Boundary should affect direction. |
| intentGranularity = AXTextSelectionGranularitySentence; |
| break; |
| case LineGranularity: |
| intentGranularity = AXTextSelectionGranularityLine; |
| break; |
| case ParagraphGranularity: |
| case ParagraphBoundary: // FIXME: Boundary should affect direction. |
| intentGranularity = AXTextSelectionGranularityParagraph; |
| break; |
| case DocumentGranularity: |
| case DocumentBoundary: // FIXME: Boundary should affect direction. |
| intentGranularity = AXTextSelectionGranularityDocument; |
| break; |
| case LineBoundary: |
| intentGranularity = AXTextSelectionGranularityLine; |
| switch (direction) { |
| case DirectionForward: |
| intentDirection = AXTextSelectionDirectionEnd; |
| break; |
| case DirectionRight: |
| intentDirection = AXTextSelectionDirectionEnd; |
| break; |
| case DirectionBackward: |
| intentDirection = AXTextSelectionDirectionBeginning; |
| break; |
| case DirectionLeft: |
| intentDirection = AXTextSelectionDirectionBeginning; |
| break; |
| } |
| break; |
| } |
| return { intentDirection, intentGranularity, false }; |
| } |
| |
| bool FrameSelection::modify(EAlteration alter, SelectionDirection direction, TextGranularity granularity, EUserTriggered userTriggered) |
| { |
| if (userTriggered == UserTriggered) { |
| FrameSelection trialFrameSelection; |
| trialFrameSelection.setSelection(m_selection); |
| trialFrameSelection.modify(alter, direction, granularity, NotUserTriggered); |
| |
| bool change = shouldChangeSelection(trialFrameSelection.selection()); |
| if (!change) |
| return false; |
| |
| if (trialFrameSelection.selection().isRange() && m_selection.isCaret() && !dispatchSelectStart()) |
| return false; |
| } |
| |
| willBeModified(alter, direction); |
| |
| bool reachedBoundary = false; |
| bool wasRange = m_selection.isRange(); |
| Position originalStartPosition = m_selection.start(); |
| VisiblePosition position; |
| switch (direction) { |
| case DirectionRight: |
| if (alter == AlterationMove) |
| position = modifyMovingRight(granularity, &reachedBoundary); |
| else |
| position = modifyExtendingRight(granularity); |
| break; |
| case DirectionForward: |
| if (alter == AlterationExtend) |
| position = modifyExtendingForward(granularity); |
| else |
| position = modifyMovingForward(granularity, &reachedBoundary); |
| break; |
| case DirectionLeft: |
| if (alter == AlterationMove) |
| position = modifyMovingLeft(granularity, &reachedBoundary); |
| else |
| position = modifyExtendingLeft(granularity); |
| break; |
| case DirectionBackward: |
| if (alter == AlterationExtend) |
| position = modifyExtendingBackward(granularity); |
| else |
| position = modifyMovingBackward(granularity, &reachedBoundary); |
| break; |
| } |
| |
| if (reachedBoundary && !isRange() && userTriggered == UserTriggered && m_frame && AXObjectCache::accessibilityEnabled()) { |
| notifyAccessibilityForSelectionChange({ AXTextStateChangeTypeSelectionBoundary, textSelectionWithDirectionAndGranularity(direction, granularity) }); |
| return true; |
| } |
| |
| if (position.isNull()) |
| return false; |
| |
| if (isSpatialNavigationEnabled(m_frame)) |
| if (!wasRange && alter == AlterationMove && position == originalStartPosition) |
| return false; |
| |
| if (m_frame && AXObjectCache::accessibilityEnabled()) { |
| if (AXObjectCache* cache = m_frame->document()->existingAXObjectCache()) |
| cache->setTextSelectionIntent(textSelectionIntent(alter, direction, granularity)); |
| } |
| |
| // Some of the above operations set an xPosForVerticalArrowNavigation. |
| // Setting a selection will clear it, so save it to possibly restore later. |
| // Note: the START position type is arbitrary because it is unused, it would be |
| // the requested position type if there were no xPosForVerticalArrowNavigation set. |
| LayoutUnit x = lineDirectionPointForBlockDirectionNavigation(START); |
| m_selection.setIsDirectional(shouldAlwaysUseDirectionalSelection(m_frame) || alter == AlterationExtend); |
| |
| switch (alter) { |
| case AlterationMove: |
| moveTo(position, userTriggered); |
| break; |
| case AlterationExtend: |
| |
| if (!m_selection.isCaret() |
| && (granularity == WordGranularity || granularity == ParagraphGranularity || granularity == LineGranularity) |
| && m_frame && !m_frame->editor().behavior().shouldExtendSelectionByWordOrLineAcrossCaret()) { |
| // Don't let the selection go across the base position directly. Needed to match mac |
| // behavior when, for instance, word-selecting backwards starting with the caret in |
| // the middle of a word and then word-selecting forward, leaving the caret in the |
| // same place where it was, instead of directly selecting to the end of the word. |
| VisibleSelection newSelection = m_selection; |
| newSelection.setExtent(position); |
| if (m_selection.isBaseFirst() != newSelection.isBaseFirst()) |
| position = m_selection.base(); |
| } |
| |
| // Standard Mac behavior when extending to a boundary is grow the selection rather than leaving the |
| // base in place and moving the extent. Matches NSTextView. |
| if (!m_frame || !m_frame->editor().behavior().shouldAlwaysGrowSelectionWhenExtendingToBoundary() || m_selection.isCaret() || !isBoundary(granularity)) |
| setExtent(position, userTriggered); |
| else { |
| TextDirection textDirection = directionOfEnclosingBlock(); |
| if (direction == DirectionForward || (textDirection == LTR && direction == DirectionRight) || (textDirection == RTL && direction == DirectionLeft)) |
| setEnd(position, userTriggered); |
| else |
| setStart(position, userTriggered); |
| } |
| break; |
| } |
| |
| if (granularity == LineGranularity || granularity == ParagraphGranularity) |
| m_xPosForVerticalArrowNavigation = x; |
| |
| if (userTriggered == UserTriggered) |
| m_granularity = CharacterGranularity; |
| |
| setCaretRectNeedsUpdate(); |
| |
| return true; |
| } |
| |
| // FIXME: Maybe baseline would be better? |
| static bool absoluteCaretY(const VisiblePosition &c, int &y) |
| { |
| IntRect rect = c.absoluteCaretBounds(); |
| if (rect.isEmpty()) |
| return false; |
| y = rect.y() + rect.height() / 2; |
| return true; |
| } |
| |
| bool FrameSelection::modify(EAlteration alter, unsigned verticalDistance, VerticalDirection direction, EUserTriggered userTriggered, CursorAlignOnScroll align) |
| { |
| if (!verticalDistance) |
| return false; |
| |
| if (userTriggered == UserTriggered) { |
| FrameSelection trialFrameSelection; |
| trialFrameSelection.setSelection(m_selection); |
| trialFrameSelection.modify(alter, verticalDistance, direction, NotUserTriggered); |
| |
| bool change = shouldChangeSelection(trialFrameSelection.selection()); |
| if (!change) |
| return false; |
| } |
| |
| willBeModified(alter, direction == DirectionUp ? DirectionBackward : DirectionForward); |
| |
| VisiblePosition pos; |
| LayoutUnit xPos = 0; |
| switch (alter) { |
| case AlterationMove: |
| pos = VisiblePosition(direction == DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity()); |
| xPos = lineDirectionPointForBlockDirectionNavigation(direction == DirectionUp ? START : END); |
| m_selection.setAffinity(direction == DirectionUp ? UPSTREAM : DOWNSTREAM); |
| break; |
| case AlterationExtend: |
| pos = VisiblePosition(m_selection.extent(), m_selection.affinity()); |
| xPos = lineDirectionPointForBlockDirectionNavigation(EXTENT); |
| m_selection.setAffinity(DOWNSTREAM); |
| break; |
| } |
| |
| int startY; |
| if (!absoluteCaretY(pos, startY)) |
| return false; |
| if (direction == DirectionUp) |
| startY = -startY; |
| int lastY = startY; |
| |
| VisiblePosition result; |
| VisiblePosition next; |
| for (VisiblePosition p = pos; ; p = next) { |
| if (direction == DirectionUp) |
| next = previousLinePosition(p, xPos); |
| else |
| next = nextLinePosition(p, xPos); |
| |
| if (next.isNull() || next == p) |
| break; |
| int nextY; |
| if (!absoluteCaretY(next, nextY)) |
| break; |
| if (direction == DirectionUp) |
| nextY = -nextY; |
| if (nextY - startY > static_cast<int>(verticalDistance)) |
| break; |
| if (nextY >= lastY) { |
| lastY = nextY; |
| result = next; |
| } |
| } |
| |
| if (result.isNull()) |
| return false; |
| |
| switch (alter) { |
| case AlterationMove: |
| moveTo(result, userTriggered, align); |
| break; |
| case AlterationExtend: |
| setExtent(result, userTriggered); |
| break; |
| } |
| |
| if (userTriggered == UserTriggered) |
| m_granularity = CharacterGranularity; |
| |
| m_selection.setIsDirectional(shouldAlwaysUseDirectionalSelection(m_frame) || alter == AlterationExtend); |
| |
| return true; |
| } |
| |
| LayoutUnit FrameSelection::lineDirectionPointForBlockDirectionNavigation(EPositionType type) |
| { |
| LayoutUnit x = 0; |
| |
| if (isNone()) |
| return x; |
| |
| Position pos; |
| switch (type) { |
| case START: |
| pos = m_selection.start(); |
| break; |
| case END: |
| pos = m_selection.end(); |
| break; |
| case BASE: |
| pos = m_selection.base(); |
| break; |
| case EXTENT: |
| pos = m_selection.extent(); |
| break; |
| } |
| |
| Frame* frame = pos.anchorNode()->document().frame(); |
| if (!frame) |
| return x; |
| |
| if (m_xPosForVerticalArrowNavigation == NoXPosForVerticalArrowNavigation()) { |
| VisiblePosition visiblePosition(pos, m_selection.affinity()); |
| // VisiblePosition creation can fail here if a node containing the selection becomes visibility:hidden |
| // after the selection is created and before this function is called. |
| x = visiblePosition.isNotNull() ? visiblePosition.lineDirectionPointForBlockDirectionNavigation() : 0; |
| m_xPosForVerticalArrowNavigation = x; |
| } else |
| x = m_xPosForVerticalArrowNavigation; |
| |
| return x; |
| } |
| |
| void FrameSelection::clear() |
| { |
| m_granularity = CharacterGranularity; |
| setSelection(VisibleSelection()); |
| } |
| |
| void FrameSelection::prepareForDestruction() |
| { |
| m_granularity = CharacterGranularity; |
| |
| #if ENABLE(TEXT_CARET) |
| m_caretBlinkTimer.stop(); |
| #endif |
| |
| if (auto* view = m_frame->contentRenderer()) |
| view->selection().clear(); |
| |
| setSelectionWithoutUpdatingAppearance(VisibleSelection(), defaultSetSelectionOptions(), AlignCursorOnScrollIfNeeded, CharacterGranularity); |
| m_previousCaretNode = nullptr; |
| } |
| |
| void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger) |
| { |
| if (m_selection.isBaseFirst()) |
| setBase(pos, trigger); |
| else |
| setExtent(pos, trigger); |
| } |
| |
| void FrameSelection::setEnd(const VisiblePosition &pos, EUserTriggered trigger) |
| { |
| if (m_selection.isBaseFirst()) |
| setExtent(pos, trigger); |
| else |
| setBase(pos, trigger); |
| } |
| |
| void FrameSelection::setBase(const VisiblePosition &pos, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(pos.deepEquivalent(), m_selection.extent(), pos.affinity(), selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::setExtent(const VisiblePosition &pos, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(m_selection.base(), pos.deepEquivalent(), pos.affinity(), selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::setBase(const Position &pos, EAffinity affinity, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(pos, m_selection.extent(), affinity, selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void FrameSelection::setExtent(const Position &pos, EAffinity affinity, EUserTriggered userTriggered) |
| { |
| const bool selectionHasDirection = true; |
| setSelection(VisibleSelection(m_selection.base(), pos, affinity, selectionHasDirection), defaultSetSelectionOptions(userTriggered)); |
| } |
| |
| void CaretBase::clearCaretRect() |
| { |
| m_caretLocalRect = LayoutRect(); |
| } |
| |
| bool CaretBase::updateCaretRect(Document* document, const VisiblePosition& caretPosition) |
| { |
| document->updateLayoutIgnorePendingStylesheets(); |
| m_caretRectNeedsUpdate = false; |
| RenderBlock* renderer; |
| m_caretLocalRect = localCaretRectInRendererForCaretPainting(caretPosition, renderer); |
| return !m_caretLocalRect.isEmpty(); |
| } |
| |
| RenderBlock* FrameSelection::caretRendererWithoutUpdatingLayout() const |
| { |
| return rendererForCaretPainting(m_selection.start().deprecatedNode()); |
| } |
| |
| RenderBlock* DragCaretController::caretRenderer() const |
| { |
| return rendererForCaretPainting(m_position.deepEquivalent().deprecatedNode()); |
| } |
| |
| static bool isNonOrphanedCaret(const VisibleSelection& selection) |
| { |
| return selection.isCaret() && !selection.start().isOrphan() && !selection.end().isOrphan(); |
| } |
| |
| IntRect FrameSelection::absoluteCaretBounds(bool* insideFixed) |
| { |
| if (!m_frame) |
| return IntRect(); |
| updateSelectionByUpdatingLayoutOrStyle(*m_frame); |
| recomputeCaretRect(); |
| if (insideFixed) |
| *insideFixed = m_caretInsidePositionFixed; |
| return m_absCaretBounds; |
| } |
| |
| static void repaintCaretForLocalRect(Node* node, const LayoutRect& rect) |
| { |
| if (auto* caretPainter = rendererForCaretPainting(node)) |
| caretPainter->repaintRectangle(rect); |
| } |
| |
| bool FrameSelection::recomputeCaretRect() |
| { |
| if (!shouldUpdateCaretRect()) |
| return false; |
| |
| if (!m_frame) |
| return false; |
| |
| FrameView* v = m_frame->document()->view(); |
| if (!v) |
| return false; |
| |
| LayoutRect oldRect = localCaretRectWithoutUpdate(); |
| |
| RefPtr<Node> caretNode = m_previousCaretNode; |
| if (shouldUpdateCaretRect()) { |
| if (!isNonOrphanedCaret(m_selection)) |
| clearCaretRect(); |
| else { |
| VisiblePosition visibleStart = m_selection.visibleStart(); |
| if (updateCaretRect(m_frame->document(), visibleStart)) { |
| caretNode = visibleStart.deepEquivalent().deprecatedNode(); |
| m_absCaretBoundsDirty = true; |
| } |
| } |
| } |
| LayoutRect newRect = localCaretRectWithoutUpdate(); |
| |
| if (caretNode == m_previousCaretNode && oldRect == newRect && !m_absCaretBoundsDirty) |
| return false; |
| |
| IntRect oldAbsCaretBounds = m_absCaretBounds; |
| bool isInsideFixed; |
| m_absCaretBounds = absoluteBoundsForLocalCaretRect(rendererForCaretPainting(caretNode.get()), newRect, &isInsideFixed); |
| m_caretInsidePositionFixed = isInsideFixed; |
| |
| if (m_absCaretBoundsDirty && m_selection.isCaret()) // We should be able to always assert this condition. |
| ASSERT(m_absCaretBounds == m_selection.visibleStart().absoluteCaretBounds()); |
| |
| m_absCaretBoundsDirty = false; |
| |
| if (caretNode == m_previousCaretNode && oldAbsCaretBounds == m_absCaretBounds) |
| return false; |
| |
| #if ENABLE(TEXT_CARET) |
| if (RenderView* view = m_frame->document()->renderView()) { |
| bool previousOrNewCaretNodeIsContentEditable = m_selection.isContentEditable() || (m_previousCaretNode && m_previousCaretNode->isContentEditable()); |
| if (shouldRepaintCaret(view, previousOrNewCaretNodeIsContentEditable)) { |
| if (m_previousCaretNode) |
| repaintCaretForLocalRect(m_previousCaretNode.get(), oldRect); |
| m_previousCaretNode = caretNode; |
| repaintCaretForLocalRect(caretNode.get(), newRect); |
| } |
| } |
| #endif |
| return true; |
| } |
| |
| bool CaretBase::shouldRepaintCaret(const RenderView* view, bool isContentEditable) const |
| { |
| ASSERT(view); |
| Frame* frame = &view->frameView().frame(); // The frame where the selection started. |
| bool caretBrowsing = frame && frame->settings().caretBrowsingEnabled(); |
| return (caretBrowsing || isContentEditable); |
| } |
| |
| void FrameSelection::invalidateCaretRect() |
| { |
| if (!isCaret()) |
| return; |
| |
| CaretBase::invalidateCaretRect(m_selection.start().deprecatedNode(), recomputeCaretRect()); |
| } |
| |
| void CaretBase::invalidateCaretRect(Node* node, bool caretRectChanged) |
| { |
| // EDIT FIXME: This is an unfortunate hack. |
| // Basically, we can't trust this layout position since we |
| // can't guarantee that the check to see if we are in unrendered |
| // content will work at this point. We may have to wait for |
| // a layout and re-render of the document to happen. So, resetting this |
| // flag will cause another caret layout to happen the first time |
| // that we try to paint the caret after this call. That one will work since |
| // it happens after the document has accounted for any editing |
| // changes which may have been done. |
| // And, we need to leave this layout here so the caret moves right |
| // away after clicking. |
| m_caretRectNeedsUpdate = true; |
| |
| if (caretRectChanged) |
| return; |
| |
| if (RenderView* view = node->document().renderView()) { |
| if (shouldRepaintCaret(view, isEditableNode(*node))) |
| repaintCaretForLocalRect(node, localCaretRectWithoutUpdate()); |
| } |
| } |
| |
| void FrameSelection::paintCaret(GraphicsContext& context, const LayoutPoint& paintOffset, const LayoutRect& clipRect) |
| { |
| if (m_selection.isCaret() && m_caretPaint) |
| CaretBase::paintCaret(m_selection.start().deprecatedNode(), context, paintOffset, clipRect); |
| } |
| |
| void CaretBase::paintCaret(Node* node, GraphicsContext& context, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const |
| { |
| #if ENABLE(TEXT_CARET) |
| if (m_caretVisibility == Hidden) |
| return; |
| |
| LayoutRect drawingRect = localCaretRectWithoutUpdate(); |
| if (auto* renderer = rendererForCaretPainting(node)) |
| renderer->flipForWritingMode(drawingRect); |
| drawingRect.moveBy(roundedIntPoint(paintOffset)); |
| LayoutRect caret = intersection(drawingRect, clipRect); |
| if (caret.isEmpty()) |
| return; |
| |
| Color caretColor = Color::black; |
| Element* element = is<Element>(*node) ? downcast<Element>(node) : node->parentElement(); |
| if (element && element->renderer()) { |
| auto computeCaretColor = [] (const RenderStyle& elementStyle, const RenderStyle* rootEditableStyle) { |
| // CSS value "auto" is treated as an invalid color. |
| if (!elementStyle.caretColor().isValid() && rootEditableStyle) { |
| auto rootEditableBackgroundColor = rootEditableStyle->visitedDependentColor(CSSPropertyBackgroundColor); |
| auto elementBackgroundColor = elementStyle.visitedDependentColor(CSSPropertyBackgroundColor); |
| auto disappearsIntoBackground = rootEditableBackgroundColor.blend(elementBackgroundColor) == rootEditableBackgroundColor; |
| if (disappearsIntoBackground) |
| return rootEditableStyle->visitedDependentColor(CSSPropertyCaretColor); |
| } |
| return elementStyle.visitedDependentColor(CSSPropertyCaretColor); |
| }; |
| auto* rootEditableElement = node->rootEditableElement(); |
| auto* rootEditableStyle = rootEditableElement && rootEditableElement->renderer() ? &rootEditableElement->renderer()->style() : nullptr; |
| caretColor = computeCaretColor(element->renderer()->style(), rootEditableStyle); |
| } |
| |
| context.fillRect(caret, caretColor); |
| #else |
| UNUSED_PARAM(node); |
| UNUSED_PARAM(context); |
| UNUSED_PARAM(paintOffset); |
| UNUSED_PARAM(clipRect); |
| #endif |
| } |
| |
| void FrameSelection::debugRenderer(RenderObject* renderer, bool selected) const |
| { |
| if (is<Element>(*renderer->node())) { |
| Element& element = downcast<Element>(*renderer->node()); |
| fprintf(stderr, "%s%s\n", selected ? "==> " : " ", element.localName().string().utf8().data()); |
| } else if (is<RenderText>(*renderer)) { |
| RenderText& textRenderer = downcast<RenderText>(*renderer); |
| if (textRenderer.text().isEmpty() || !textRenderer.firstTextBox()) { |
| fprintf(stderr, "%s#text (empty)\n", selected ? "==> " : " "); |
| return; |
| } |
| |
| static const int max = 36; |
| String text = textRenderer.text(); |
| int textLength = text.length(); |
| if (selected) { |
| int offset = 0; |
| if (renderer->node() == m_selection.start().containerNode()) |
| offset = m_selection.start().computeOffsetInContainerNode(); |
| else if (renderer->node() == m_selection.end().containerNode()) |
| offset = m_selection.end().computeOffsetInContainerNode(); |
| |
| int pos; |
| InlineTextBox* box = textRenderer.findNextInlineTextBox(offset, pos); |
| text = text.substring(box->start(), box->len()); |
| |
| String show; |
| int mid = max / 2; |
| int caret = 0; |
| |
| // text is shorter than max |
| if (textLength < max) { |
| show = text; |
| caret = pos; |
| } else if (pos - mid < 0) { |
| // too few characters to left |
| show = text.left(max - 3) + "..."; |
| caret = pos; |
| } else if (pos - mid >= 0 && pos + mid <= textLength) { |
| // enough characters on each side |
| show = "..." + text.substring(pos - mid + 3, max - 6) + "..."; |
| caret = mid; |
| } else { |
| // too few characters on right |
| show = "..." + text.right(max - 3); |
| caret = pos - (textLength - show.length()); |
| } |
| |
| show.replace('\n', ' '); |
| show.replace('\r', ' '); |
| fprintf(stderr, "==> #text : \"%s\" at offset %d\n", show.utf8().data(), pos); |
| fprintf(stderr, " "); |
| for (int i = 0; i < caret; i++) |
| fprintf(stderr, " "); |
| fprintf(stderr, "^\n"); |
| } else { |
| if ((int)text.length() > max) |
| text = text.left(max - 3) + "..."; |
| else |
| text = text.left(max); |
| fprintf(stderr, " #text : \"%s\"\n", text.utf8().data()); |
| } |
| } |
| } |
| |
| bool FrameSelection::contains(const LayoutPoint& point) const |
| { |
| // Treat a collapsed selection like no selection. |
| if (!isRange()) |
| return false; |
| |
| RenderView* renderView = m_frame->contentRenderer(); |
| if (!renderView) |
| return false; |
| |
| HitTestResult result(point); |
| renderView->hitTest(HitTestRequest(), result); |
| Node* innerNode = result.innerNode(); |
| if (!innerNode || !innerNode->renderer()) |
| return false; |
| |
| VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(result.localPoint(), nullptr)); |
| if (visiblePos.isNull()) |
| return false; |
| |
| if (m_selection.visibleStart().isNull() || m_selection.visibleEnd().isNull()) |
| return false; |
| |
| Position start(m_selection.visibleStart().deepEquivalent()); |
| Position end(m_selection.visibleEnd().deepEquivalent()); |
| Position p(visiblePos.deepEquivalent()); |
| |
| return comparePositions(start, p) <= 0 && comparePositions(p, end) <= 0; |
| } |
| |
| // Workaround for the fact that it's hard to delete a frame. |
| // Call this after doing user-triggered selections to make it easy to delete the frame you entirely selected. |
| // Can't do this implicitly as part of every setSelection call because in some contexts it might not be good |
| // for the focus to move to another frame. So instead we call it from places where we are selecting with the |
| // mouse or the keyboard after setting the selection. |
| void FrameSelection::selectFrameElementInParentIfFullySelected() |
| { |
| // Find the parent frame; if there is none, then we have nothing to do. |
| Frame* parent = m_frame->tree().parent(); |
| if (!parent) |
| return; |
| Page* page = m_frame->page(); |
| if (!page) |
| return; |
| |
| // Check if the selection contains the entire frame contents; if not, then there is nothing to do. |
| if (!isRange()) |
| return; |
| if (!isStartOfDocument(selection().visibleStart())) |
| return; |
| if (!isEndOfDocument(selection().visibleEnd())) |
| return; |
| |
| // Get to the <iframe> or <frame> (or even <object>) element in the parent frame. |
| Element* ownerElement = m_frame->ownerElement(); |
| if (!ownerElement) |
| return; |
| ContainerNode* ownerElementParent = ownerElement->parentNode(); |
| if (!ownerElementParent) |
| return; |
| |
| // This method's purpose is it to make it easier to select iframes (in order to delete them). Don't do anything if the iframe isn't deletable. |
| if (!ownerElementParent->hasEditableStyle()) |
| return; |
| |
| // Create compute positions before and after the element. |
| unsigned ownerElementNodeIndex = ownerElement->computeNodeIndex(); |
| VisiblePosition beforeOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex, Position::PositionIsOffsetInAnchor))); |
| VisiblePosition afterOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1, Position::PositionIsOffsetInAnchor), VP_UPSTREAM_IF_POSSIBLE)); |
| |
| // Focus on the parent frame, and then select from before this element to after. |
| VisibleSelection newSelection(beforeOwnerElement, afterOwnerElement); |
| if (parent->selection().shouldChangeSelection(newSelection)) { |
| page->focusController().setFocusedFrame(parent); |
| parent->selection().setSelection(newSelection); |
| } |
| } |
| |
| void FrameSelection::selectAll() |
| { |
| Document* document = m_frame->document(); |
| |
| Element* focusedElement = document->focusedElement(); |
| if (is<HTMLSelectElement>(focusedElement)) { |
| HTMLSelectElement& selectElement = downcast<HTMLSelectElement>(*focusedElement); |
| if (selectElement.canSelectAll()) { |
| selectElement.selectAll(); |
| return; |
| } |
| } |
| |
| RefPtr<Node> root; |
| Node* selectStartTarget = nullptr; |
| if (m_selection.isContentEditable()) { |
| root = highestEditableRoot(m_selection.start()); |
| if (Node* shadowRoot = m_selection.nonBoundaryShadowTreeRootNode()) |
| selectStartTarget = shadowRoot->shadowHost(); |
| else |
| selectStartTarget = root.get(); |
| } else { |
| if (m_selection.isNone() && focusedElement) { |
| if (focusedElement->isTextField()) { |
| downcast<HTMLTextFormControlElement>(*focusedElement).select(); |
| return; |
| } |
| root = focusedElement->nonBoundaryShadowTreeRootNode(); |
| } else |
| root = m_selection.nonBoundaryShadowTreeRootNode(); |
| |
| if (root) |
| selectStartTarget = root->shadowHost(); |
| else { |
| root = document->documentElement(); |
| selectStartTarget = document->bodyOrFrameset(); |
| } |
| } |
| if (!root) |
| return; |
| |
| if (selectStartTarget) { |
| auto event = Event::create(eventNames().selectstartEvent, true, true); |
| selectStartTarget->dispatchEvent(event); |
| if (event->defaultPrevented()) |
| return; |
| } |
| |
| VisibleSelection newSelection(VisibleSelection::selectionFromContentsOfNode(root.get())); |
| |
| if (shouldChangeSelection(newSelection)) { |
| AXTextStateChangeIntent intent(AXTextStateChangeTypeSelectionExtend, AXTextSelection { AXTextSelectionDirectionDiscontiguous, AXTextSelectionGranularityAll, false }); |
| setSelection(newSelection, defaultSetSelectionOptions() | FireSelectEvent, intent); |
| } |
| } |
| |
| bool FrameSelection::setSelectedRange(Range* range, EAffinity affinity, bool closeTyping, EUserTriggered userTriggered) |
| { |
| if (!range) |
| return false; |
| ASSERT(&range->startContainer().document() == &range->endContainer().document()); |
| |
| VisibleSelection newSelection(*range, affinity); |
| |
| #if PLATFORM(IOS) |
| // FIXME: Why do we need this check only in iOS? |
| if (newSelection.isNone()) |
| return false; |
| #endif |
| |
| if (userTriggered == UserTriggered) { |
| FrameSelection trialFrameSelection; |
| trialFrameSelection.setSelection(newSelection, ClearTypingStyle | (closeTyping ? CloseTyping : 0)); |
| |
| if (!shouldChangeSelection(trialFrameSelection.selection())) |
| return false; |
| } |
| |
| setSelection(newSelection, ClearTypingStyle | (closeTyping ? CloseTyping : 0) | (userTriggered == UserTriggered ? IsUserTriggered : 0)); |
| return true; |
| } |
| |
| void FrameSelection::focusedOrActiveStateChanged() |
| { |
| bool activeAndFocused = isFocusedAndActive(); |
| Ref<Document> document(*m_frame->document()); |
| |
| document->updateStyleIfNeeded(); |
| |
| #if USE(UIKIT_EDITING) |
| // Caret blinking (blinks | does not blink) |
| if (activeAndFocused) |
| setSelectionFromNone(); |
| setCaretVisible(activeAndFocused); |
| #else |
| // Because RenderObject::selectionBackgroundColor() and |
| // RenderObject::selectionForegroundColor() check if the frame is active, |
| // we have to update places those colors were painted. |
| if (RenderView* view = document->renderView()) |
| view->selection().repaint(); |
| |
| // Caret appears in the active frame. |
| if (activeAndFocused) |
| setSelectionFromNone(); |
| setCaretVisibility(activeAndFocused ? Visible : Hidden); |
| |
| // Because StyleResolver::checkOneSelector() and |
| // RenderTheme::isFocused() check if the frame is active, we have to |
| // update style and theme state that depended on those. |
| if (Element* element = document->focusedElement()) { |
| element->invalidateStyleForSubtree(); |
| if (RenderObject* renderer = element->renderer()) |
| if (renderer && renderer->style().hasAppearance()) |
| renderer->theme().stateChanged(*renderer, ControlStates::FocusState); |
| } |
| #endif |
| } |
| |
| void FrameSelection::pageActivationChanged() |
| { |
| focusedOrActiveStateChanged(); |
| } |
| |
| void FrameSelection::setFocused(bool flag) |
| { |
| if (m_focused == flag) |
| return; |
| m_focused = flag; |
| |
| focusedOrActiveStateChanged(); |
| } |
| |
| bool FrameSelection::isFocusedAndActive() const |
| { |
| return m_focused && m_frame->page() && m_frame->page()->focusController().isActive(); |
| } |
| |
| #if ENABLE(TEXT_CARET) |
| inline static bool shouldStopBlinkingDueToTypingCommand(Frame* frame) |
| { |
| return frame->editor().lastEditCommand() && frame->editor().lastEditCommand()->shouldStopCaretBlinking(); |
| } |
| #endif |
| |
| void FrameSelection::updateAppearance() |
| { |
| #if PLATFORM(IOS) |
| if (!m_updateAppearanceEnabled) |
| return; |
| #endif |
| |
| // Paint a block cursor instead of a caret in overtype mode unless the caret is at the end of a line (in this case |
| // the FrameSelection will paint a blinking caret as usual). |
| VisibleSelection oldSelection = selection(); |
| |
| #if ENABLE(TEXT_CARET) |
| bool paintBlockCursor = m_shouldShowBlockCursor && m_selection.isCaret() && !isLogicalEndOfLine(m_selection.visibleEnd()); |
| bool caretRectChangedOrCleared = recomputeCaretRect(); |
| |
| bool caretBrowsing = m_frame->settings().caretBrowsingEnabled(); |
| bool shouldBlink = !paintBlockCursor && caretIsVisible() && isCaret() && (oldSelection.isContentEditable() || caretBrowsing); |
| |
| // If the caret moved, stop the blink timer so we can restart with a |
| // black caret in the new location. |
| if (caretRectChangedOrCleared || !shouldBlink || shouldStopBlinkingDueToTypingCommand(m_frame)) |
| m_caretBlinkTimer.stop(); |
| |
| // Start blinking with a black caret. Be sure not to restart if we're |
| // already blinking in the right location. |
| if (shouldBlink && !m_caretBlinkTimer.isActive()) { |
| if (Seconds blinkInterval = RenderTheme::singleton().caretBlinkInterval()) |
| m_caretBlinkTimer.startRepeating(blinkInterval); |
| |
| if (!m_caretPaint) { |
| m_caretPaint = true; |
| invalidateCaretRect(); |
| } |
| } |
| #endif |
| |
| RenderView* view = m_frame->contentRenderer(); |
| if (!view) |
| return; |
| |
| // Construct a new VisibleSolution, since m_selection is not necessarily valid, and the following steps |
| // assume a valid selection. See <https://bugs.webkit.org/show_bug.cgi?id=69563> and <rdar://problem/10232866>. |
| #if ENABLE(TEXT_CARET) |
| VisiblePosition endVisiblePosition = paintBlockCursor ? modifyExtendingForward(CharacterGranularity) : oldSelection.visibleEnd(); |
| VisibleSelection selection(oldSelection.visibleStart(), endVisiblePosition); |
| #else |
| VisibleSelection selection(oldSelection.visibleStart(), oldSelection.visibleEnd()); |
| #endif |
| |
| if (!selection.isRange()) { |
| view->selection().clear(); |
| return; |
| } |
| |
| // Use the rightmost candidate for the start of the selection, and the leftmost candidate for the end of the selection. |
| // Example: foo <a>bar</a>. Imagine that a line wrap occurs after 'foo', and that 'bar' is selected. If we pass [foo, 3] |
| // as the start of the selection, the selection painting code will think that content on the line containing 'foo' is selected |
| // and will fill the gap before 'bar'. |
| Position startPos = selection.start(); |
| Position candidate = startPos.downstream(); |
| if (candidate.isCandidate()) |
| startPos = candidate; |
| Position endPos = selection.end(); |
| candidate = endPos.upstream(); |
| if (candidate.isCandidate()) |
| endPos = candidate; |
| |
| // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted |
| // because we don't yet notify the FrameSelection of text removal. |
| if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) { |
| RenderObject* startRenderer = startPos.deprecatedNode()->renderer(); |
| int startOffset = startPos.deprecatedEditingOffset(); |
| RenderObject* endRenderer = endPos.deprecatedNode()->renderer(); |
| int endOffset = endPos.deprecatedEditingOffset(); |
| ASSERT(startOffset >= 0 && endOffset >= 0); |
| view->selection().set({ startRenderer, endRenderer, static_cast<unsigned>(startOffset), static_cast<unsigned>(endOffset) }); |
| } |
| } |
| |
| void FrameSelection::setCaretVisibility(CaretVisibility visibility) |
| { |
| if (caretVisibility() == visibility) |
| return; |
| |
| // FIXME: We shouldn't trigger a synchronous layout here. |
| if (m_frame) |
| updateSelectionByUpdatingLayoutOrStyle(*m_frame); |
| |
| #if ENABLE(TEXT_CARET) |
| if (m_caretPaint) { |
| m_caretPaint = false; |
| invalidateCaretRect(); |
| } |
| CaretBase::setCaretVisibility(visibility); |
| #endif |
| |
| updateAppearance(); |
| } |
| |
| void FrameSelection::caretBlinkTimerFired() |
| { |
| #if ENABLE(TEXT_CARET) |
| ASSERT(caretIsVisible()); |
| ASSERT(isCaret()); |
| bool caretPaint = m_caretPaint; |
| if (isCaretBlinkingSuspended() && caretPaint) |
| return; |
| m_caretPaint = !caretPaint; |
| invalidateCaretRect(); |
| #endif |
| } |
| |
| // Helper function that tells whether a particular node is an element that has an entire |
| // Frame and FrameView, a <frame>, <iframe>, or <object>. |
| static bool isFrameElement(const Node* n) |
| { |
| if (!n) |
| return false; |
| RenderObject* renderer = n->renderer(); |
| if (!is<RenderWidget>(renderer)) |
| return false; |
| Widget* widget = downcast<RenderWidget>(*renderer).widget(); |
| return widget && widget->isFrameView(); |
| } |
| |
| void FrameSelection::setFocusedElementIfNeeded() |
| { |
| if (isNone() || !isFocused()) |
| return; |
| |
| bool caretBrowsing = m_frame->settings().caretBrowsingEnabled(); |
| if (caretBrowsing) { |
| if (Element* anchor = enclosingAnchorElement(m_selection.base())) { |
| m_frame->page()->focusController().setFocusedElement(anchor, *m_frame); |
| return; |
| } |
| } |
| |
| if (Element* target = m_selection.rootEditableElement()) { |
| // Walk up the DOM tree to search for an element to focus. |
| while (target) { |
| // We don't want to set focus on a subframe when selecting in a parent frame, |
| // so add the !isFrameElement check here. There's probably a better way to make this |
| // work in the long term, but this is the safest fix at this time. |
| if (target->isMouseFocusable() && !isFrameElement(target)) { |
| m_frame->page()->focusController().setFocusedElement(target, *m_frame); |
| return; |
| } |
| target = target->parentOrShadowHostElement(); |
| } |
| m_frame->document()->setFocusedElement(nullptr); |
| } |
| |
| if (caretBrowsing) |
| m_frame->page()->focusController().setFocusedElement(nullptr, *m_frame); |
| } |
| |
| void DragCaretController::paintDragCaret(Frame* frame, GraphicsContext& p, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const |
| { |
| #if ENABLE(TEXT_CARET) |
| if (m_position.deepEquivalent().deprecatedNode()->document().frame() == frame) |
| paintCaret(m_position.deepEquivalent().deprecatedNode(), p, paintOffset, clipRect); |
| #else |
| UNUSED_PARAM(frame); |
| UNUSED_PARAM(p); |
| UNUSED_PARAM(paintOffset); |
| UNUSED_PARAM(clipRect); |
| #endif |
| } |
| |
| RefPtr<MutableStyleProperties> FrameSelection::copyTypingStyle() const |
| { |
| if (!m_typingStyle || !m_typingStyle->style()) |
| return nullptr; |
| return m_typingStyle->style()->mutableCopy(); |
| } |
| |
| bool FrameSelection::shouldDeleteSelection(const VisibleSelection& selection) const |
| { |
| #if PLATFORM(IOS) |
| if (m_frame->selectionChangeCallbacksDisabled()) |
| return true; |
| #endif |
| return m_frame->editor().client()->shouldDeleteRange(selection.toNormalizedRange().get()); |
| } |
| |
| FloatRect FrameSelection::selectionBounds(bool clipToVisibleContent) const |
| { |
| if (!m_frame->document()) |
| return LayoutRect(); |
| |
| updateSelectionByUpdatingLayoutOrStyle(*m_frame); |
| auto* renderView = m_frame->contentRenderer(); |
| if (!renderView) |
| return LayoutRect(); |
| |
| auto& selection = renderView->selection(); |
| auto selectionRect = clipToVisibleContent ? selection.boundsClippedToVisibleContent() : selection.bounds(); |
| return clipToVisibleContent ? intersection(selectionRect, renderView->frameView().visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect)) : selectionRect; |
| } |
| |
| void FrameSelection::getClippedVisibleTextRectangles(Vector<FloatRect>& rectangles, TextRectangleHeight textRectHeight) const |
| { |
| RenderView* root = m_frame->contentRenderer(); |
| if (!root) |
| return; |
| |
| Vector<FloatRect> textRects; |
| getTextRectangles(textRects, textRectHeight); |
| |
| FloatRect visibleContentRect = m_frame->view()->visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect); |
| |
| for (const auto& rect : textRects) { |
| FloatRect intersectionRect = intersection(rect, visibleContentRect); |
| if (!intersectionRect.isEmpty()) |
| rectangles.append(intersectionRect); |
| } |
| } |
| |
| void FrameSelection::getTextRectangles(Vector<FloatRect>& rectangles, TextRectangleHeight textRectHeight) const |
| { |
| RefPtr<Range> range = toNormalizedRange(); |
| if (!range) |
| return; |
| |
| Vector<FloatQuad> quads; |
| range->absoluteTextQuads(quads, textRectHeight == TextRectangleHeight::SelectionHeight); |
| |
| for (const auto& quad : quads) |
| rectangles.append(quad.boundingBox()); |
| } |
| |
| // Scans logically forward from "start", including any child frames. |
| static HTMLFormElement* scanForForm(Element* start) |
| { |
| if (!start) |
| return nullptr; |
| |
| auto descendants = descendantsOfType<HTMLElement>(start->document()); |
| for (auto it = descendants.from(*start), end = descendants.end(); it != end; ++it) { |
| HTMLElement& element = *it; |
| if (is<HTMLFormElement>(element)) |
| return &downcast<HTMLFormElement>(element); |
| if (is<HTMLFormControlElement>(element)) |
| return downcast<HTMLFormControlElement>(element).form(); |
| if (is<HTMLFrameElementBase>(element)) { |
| Document* contentDocument = downcast<HTMLFrameElementBase>(element).contentDocument(); |
| if (!contentDocument) |
| continue; |
| if (HTMLFormElement* frameResult = scanForForm(contentDocument->documentElement())) |
| return frameResult; |
| } |
| } |
| return nullptr; |
| } |
| |
| // We look for either the form containing the current focus, or for one immediately after it |
| HTMLFormElement* FrameSelection::currentForm() const |
| { |
| // Start looking either at the active (first responder) node, or where the selection is. |
| Element* start = m_frame->document()->focusedElement(); |
| if (!start) |
| start = m_selection.start().element(); |
| if (!start) |
| return nullptr; |
| |
| if (auto form = lineageOfType<HTMLFormElement>(*start).first()) |
| return form; |
| if (auto formControl = lineageOfType<HTMLFormControlElement>(*start).first()) |
| return formControl->form(); |
| |
| // Try walking forward in the node tree to find a form element. |
| return scanForForm(start); |
| } |
| |
| void FrameSelection::revealSelection(SelectionRevealMode revealMode, const ScrollAlignment& alignment, RevealExtentOption revealExtentOption) |
| { |
| if (revealMode == SelectionRevealMode::DoNotReveal) |
| return; |
| |
| LayoutRect rect; |
| bool insideFixed = false; |
| switch (m_selection.selectionType()) { |
| case VisibleSelection::NoSelection: |
| return; |
| case VisibleSelection::CaretSelection: |
| rect = absoluteCaretBounds(&insideFixed); |
| break; |
| case VisibleSelection::RangeSelection: |
| rect = revealExtentOption == RevealExtent ? VisiblePosition(m_selection.extent()).absoluteCaretBounds() : enclosingIntRect(selectionBounds(false)); |
| break; |
| } |
| |
| Position start = m_selection.start(); |
| ASSERT(start.deprecatedNode()); |
| if (start.deprecatedNode() && start.deprecatedNode()->renderer()) { |
| #if PLATFORM(IOS) |
| if (RenderLayer* layer = start.deprecatedNode()->renderer()->enclosingLayer()) { |
| if (!m_scrollingSuppressCount) { |
| layer->setAdjustForIOSCaretWhenScrolling(true); |
| layer->scrollRectToVisible(revealMode, rect, insideFixed, alignment, alignment); |
| layer->setAdjustForIOSCaretWhenScrolling(false); |
| updateAppearance(); |
| if (m_frame->page()) |
| m_frame->page()->chrome().client().notifyRevealedSelectionByScrollingFrame(*m_frame); |
| } |
| } |
| #else |
| // FIXME: This code only handles scrolling the startContainer's layer, but |
| // the selection rect could intersect more than just that. |
| // See <rdar://problem/4799899>. |
| if (start.deprecatedNode()->renderer()->scrollRectToVisible(revealMode, rect, insideFixed, alignment, alignment)) |
| updateAppearance(); |
| #endif |
| } |
| } |
| |
| void FrameSelection::setSelectionFromNone() |
| { |
| // Put a caret inside the body if the entire frame is editable (either the |
| // entire WebView is editable or designMode is on for this document). |
| |
| Document* document = m_frame->document(); |
| #if !PLATFORM(IOS) |
| bool caretBrowsing = m_frame->settings().caretBrowsingEnabled(); |
| if (!isNone() || !(document->hasEditableStyle() || caretBrowsing)) |
| return; |
| #else |
| if (!document || !(isNone() || isStartOfDocument(VisiblePosition(m_selection.start(), m_selection.affinity()))) || !document->hasEditableStyle()) |
| return; |
| #endif |
| |
| if (auto* body = document->body()) |
| setSelection(VisibleSelection(firstPositionInOrBeforeNode(body), DOWNSTREAM)); |
| } |
| |
| bool FrameSelection::shouldChangeSelection(const VisibleSelection& newSelection) const |
| { |
| #if PLATFORM(IOS) |
| if (m_frame->selectionChangeCallbacksDisabled()) |
| return true; |
| #endif |
| return m_frame->editor().shouldChangeSelection(selection(), newSelection, newSelection.affinity(), false); |
| } |
| |
| bool FrameSelection::dispatchSelectStart() |
| { |
| Node* selectStartTarget = m_selection.extent().containerNode(); |
| if (!selectStartTarget) |
| return true; |
| |
| auto event = Event::create(eventNames().selectstartEvent, true, true); |
| selectStartTarget->dispatchEvent(event); |
| return !event->defaultPrevented(); |
| } |
| |
| void FrameSelection::setShouldShowBlockCursor(bool shouldShowBlockCursor) |
| { |
| m_shouldShowBlockCursor = shouldShowBlockCursor; |
| |
| m_frame->document()->updateLayoutIgnorePendingStylesheets(); |
| |
| updateAppearance(); |
| } |
| |
| void FrameSelection::updateAppearanceAfterLayout() |
| { |
| m_appearanceUpdateTimer.stop(); |
| updateAppearanceAfterLayoutOrStyleChange(); |
| } |
| |
| void FrameSelection::scheduleAppearanceUpdateAfterStyleChange() |
| { |
| m_appearanceUpdateTimer.startOneShot(0_s); |
| } |
| |
| void FrameSelection::appearanceUpdateTimerFired() |
| { |
| updateAppearanceAfterLayoutOrStyleChange(); |
| } |
| |
| void FrameSelection::updateAppearanceAfterLayoutOrStyleChange() |
| { |
| if (auto* client = m_frame->editor().client()) |
| client->updateEditorStateAfterLayoutIfEditabilityChanged(); |
| |
| setCaretRectNeedsUpdate(); |
| updateAndRevealSelection(m_selectionRevealIntent); |
| updateDataDetectorsForSelection(); |
| } |
| |
| #if ENABLE(TREE_DEBUGGING) |
| |
| void FrameSelection::formatForDebugger(char* buffer, unsigned length) const |
| { |
| m_selection.formatForDebugger(buffer, length); |
| } |
| |
| void FrameSelection::showTreeForThis() const |
| { |
| m_selection.showTreeForThis(); |
| } |
| |
| #endif |
| |
| #if PLATFORM(IOS) |
| void FrameSelection::expandSelectionToElementContainingCaretSelection() |
| { |
| RefPtr<Range> range = elementRangeContainingCaretSelection(); |
| if (!range) |
| return; |
| VisibleSelection selection(*range, DOWNSTREAM); |
| setSelection(selection); |
| } |
| |
| RefPtr<Range> FrameSelection::elementRangeContainingCaretSelection() const |
| { |
| if (m_selection.isNone()) |
| return nullptr; |
| |
| VisibleSelection selection = m_selection; |
| if (selection.isNone()) |
| return nullptr; |
| |
| VisiblePosition visiblePos(selection.start(), VP_DEFAULT_AFFINITY); |
| if (visiblePos.isNull()) |
| return nullptr; |
| |
| Node* node = visiblePos.deepEquivalent().deprecatedNode(); |
| Element* element = deprecatedEnclosingBlockFlowElement(node); |
| if (!element) |
| return nullptr; |
| |
| Position startPos = createLegacyEditingPosition(element, 0); |
| Position endPos = createLegacyEditingPosition(element, element->countChildNodes()); |
| |
| VisiblePosition startVisiblePos(startPos, VP_DEFAULT_AFFINITY); |
| VisiblePosition endVisiblePos(endPos, VP_DEFAULT_AFFINITY); |
| if (startVisiblePos.isNull() || endVisiblePos.isNull()) |
| return nullptr; |
| |
| selection.setBase(startVisiblePos); |
| selection.setExtent(endVisiblePos); |
| |
| return selection.toNormalizedRange(); |
| } |
| |
| void FrameSelection::expandSelectionToWordContainingCaretSelection() |
| { |
| VisibleSelection selection(wordSelectionContainingCaretSelection(m_selection)); |
| if (selection.isCaretOrRange()) |
| setSelection(selection); |
| } |
| |
| RefPtr<Range> FrameSelection::wordRangeContainingCaretSelection() |
| { |
| return wordSelectionContainingCaretSelection(m_selection).toNormalizedRange(); |
| } |
| |
| void FrameSelection::expandSelectionToStartOfWordContainingCaretSelection() |
| { |
| if (m_selection.isNone() || isStartOfDocument(m_selection.start())) |
| return; |
| |
| VisiblePosition s1(m_selection.start()); |
| VisiblePosition e1(m_selection.end()); |
| |
| VisibleSelection expanded(wordSelectionContainingCaretSelection(m_selection)); |
| VisiblePosition s2(expanded.start()); |
| |
| // Don't allow the start to become greater after the expansion. |
| if (s2.isNull() || s2 > s1) |
| s2 = s1; |
| |
| moveTo(s2, e1); |
| } |
| |
| UChar FrameSelection::characterInRelationToCaretSelection(int amount) const |
| { |
| if (m_selection.isNone()) |
| return 0; |
| |
| VisibleSelection selection = m_selection; |
| ASSERT(selection.isCaretOrRange()); |
| |
| VisiblePosition visiblePosition(selection.start(), VP_DEFAULT_AFFINITY); |
| |
| if (amount < 0) { |
| int count = abs(amount); |
| for (int i = 0; i < count; i++) |
| visiblePosition = visiblePosition.previous(); |
| return visiblePosition.characterBefore(); |
| } |
| for (int i = 0; i < amount; i++) |
| visiblePosition = visiblePosition.next(); |
| return visiblePosition.characterAfter(); |
| } |
| |
| UChar FrameSelection::characterBeforeCaretSelection() const |
| { |
| if (m_selection.isNone()) |
| return 0; |
| |
| VisibleSelection selection = m_selection; |
| ASSERT(selection.isCaretOrRange()); |
| |
| VisiblePosition visiblePosition(selection.start(), VP_DEFAULT_AFFINITY); |
| return visiblePosition.characterBefore(); |
| } |
| |
| UChar FrameSelection::characterAfterCaretSelection() const |
| { |
| if (m_selection.isNone()) |
| return 0; |
| |
| VisibleSelection selection = m_selection; |
| ASSERT(selection.isCaretOrRange()); |
| |
| VisiblePosition visiblePosition(selection.end(), VP_DEFAULT_AFFINITY); |
| return visiblePosition.characterAfter(); |
| } |
| |
| int FrameSelection::wordOffsetInRange(const Range *range) const |
| { |
| if (!range) |
| return -1; |
| |
| VisibleSelection selection = m_selection; |
| if (!selection.isCaret()) |
| return -1; |
| |
| // FIXME: This will only work in cases where the selection remains in |
| // the same node after it is expanded. Improve to handle more complicated |
| // cases. |
| int result = selection.start().deprecatedEditingOffset() - range->startOffset(); |
| if (result < 0) |
| result = 0; |
| return result; |
| } |
| |
| bool FrameSelection::spaceFollowsWordInRange(const Range *range) const |
| { |
| if (!range) |
| return false; |
| Node& node = range->endContainer(); |
| int endOffset = range->endOffset(); |
| VisiblePosition pos(createLegacyEditingPosition(&node, endOffset), VP_DEFAULT_AFFINITY); |
| return isSpaceOrNewline(pos.characterAfter()); |
| } |
| |
| bool FrameSelection::selectionAtDocumentStart() const |
| { |
| VisibleSelection selection = m_selection; |
| if (selection.isNone()) |
| return false; |
| |
| Position startPos(selection.start()); |
| VisiblePosition pos(createLegacyEditingPosition(startPos.deprecatedNode(), startPos.deprecatedEditingOffset()), VP_DEFAULT_AFFINITY); |
| if (pos.isNull()) |
| return false; |
| |
| return isStartOfDocument(pos); |
| } |
| |
| bool FrameSelection::selectionAtSentenceStart() const |
| { |
| VisibleSelection selection = m_selection; |
| if (selection.isNone()) |
| return false; |
| |
| return actualSelectionAtSentenceStart(selection); |
| } |
| |
| bool FrameSelection::selectionAtWordStart() const |
| { |
| VisibleSelection selection = m_selection; |
| if (selection.isNone()) |
| return false; |
| |
| Position startPos(selection.start()); |
| VisiblePosition pos(createLegacyEditingPosition(startPos.deprecatedNode(), startPos.deprecatedEditingOffset()), VP_DEFAULT_AFFINITY); |
| if (pos.isNull()) |
| return false; |
| |
| if (isStartOfParagraph(pos)) |
| return true; |
| |
| bool result = true; |
| unsigned previousCount = 0; |
| for (pos = pos.previous(); !pos.isNull(); pos = pos.previous()) { |
| previousCount++; |
| if (isStartOfParagraph(pos)) { |
| if (previousCount == 1) |
| result = false; |
| break; |
| } |
| UChar c(pos.characterAfter()); |
| if (c) { |
| result = isSpaceOrNewline(c) || c == noBreakSpace || (u_ispunct(c) && c != ',' && c != '-' && c != '\''); |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| RefPtr<Range> FrameSelection::rangeByMovingCurrentSelection(int amount) const |
| { |
| return rangeByAlteringCurrentSelection(AlterationMove, amount); |
| } |
| |
| RefPtr<Range> FrameSelection::rangeByExtendingCurrentSelection(int amount) const |
| { |
| return rangeByAlteringCurrentSelection(AlterationExtend, amount); |
| } |
| |
| void FrameSelection::selectRangeOnElement(unsigned location, unsigned length, Node& node) |
| { |
| RefPtr<Range> resultRange = m_frame->document()->createRange(); |
| resultRange->setStart(node, location); |
| resultRange->setEnd(node, location + length); |
| VisibleSelection selection = VisibleSelection(*resultRange, SEL_DEFAULT_AFFINITY); |
| setSelection(selection, true); |
| } |
| |
| VisibleSelection FrameSelection::wordSelectionContainingCaretSelection(const VisibleSelection& selection) |
| { |
| if (selection.isNone()) |
| return VisibleSelection(); |
| |
| ASSERT(selection.isCaretOrRange()); |
| FrameSelection frameSelection; |
| frameSelection.setSelection(selection); |
| |
| Position startPosBeforeExpansion(selection.start()); |
| Position endPosBeforeExpansion(selection.end()); |
| VisiblePosition startVisiblePosBeforeExpansion(startPosBeforeExpansion, VP_DEFAULT_AFFINITY); |
| VisiblePosition endVisiblePosBeforeExpansion(endPosBeforeExpansion, VP_DEFAULT_AFFINITY); |
| if (endVisiblePosBeforeExpansion.isNull()) |
| return VisibleSelection(); |
| |
| if (isEndOfParagraph(endVisiblePosBeforeExpansion)) { |
| UChar c(endVisiblePosBeforeExpansion.characterBefore()); |
| if (isSpaceOrNewline(c) || c == noBreakSpace) { |
| // End of paragraph with space. |
| return VisibleSelection(); |
| } |
| } |
| |
| // If at end of paragraph, move backwards one character. |
| // This has the effect of selecting the word on the line (which is |
| // what we want, rather than selecting past the end of the line). |
| if (isEndOfParagraph(endVisiblePosBeforeExpansion) && !isStartOfParagraph(endVisiblePosBeforeExpansion)) |
| frameSelection.modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity); |
| |
| VisibleSelection newSelection = frameSelection.selection(); |
| newSelection.expandUsingGranularity(WordGranularity); |
| frameSelection.setSelection(newSelection, defaultSetSelectionOptions(), AXTextStateChangeIntent(), AlignCursorOnScrollIfNeeded, frameSelection.granularity()); |
| |
| Position startPos(frameSelection.selection().start()); |
| Position endPos(frameSelection.selection().end()); |
| |
| // Expansion cannot be allowed to change selection so that it is no longer |
| // touches (or contains) the original, unexpanded selection. |
| // Enforce this on the way into these additional calculations to give them |
| // the best chance to yield a suitable answer. |
| if (startPos > startPosBeforeExpansion) |
| startPos = startPosBeforeExpansion; |
| if (endPos < endPosBeforeExpansion) |
| endPos = endPosBeforeExpansion; |
| |
| VisiblePosition startVisiblePos(startPos, VP_DEFAULT_AFFINITY); |
| VisiblePosition endVisiblePos(endPos, VP_DEFAULT_AFFINITY); |
| |
| if (startVisiblePos.isNull() || endVisiblePos.isNull()) { |
| // Start or end is nil |
| return VisibleSelection(); |
| } |
| |
| if (isEndOfLine(endVisiblePosBeforeExpansion)) { |
| VisiblePosition previous(endVisiblePos.previous()); |
| if (previous == endVisiblePos) { |
| // Empty document |
| return VisibleSelection(); |
| } |
| UChar c(previous.characterAfter()); |
| if (isSpaceOrNewline(c) || c == noBreakSpace) { |
| // Space at end of line |
| return VisibleSelection(); |
| } |
| } |
| |
| // Expansion has selected past end of line. |
| // Try repositioning backwards. |
| if (isEndOfLine(startVisiblePos) && isStartOfLine(endVisiblePos)) { |
| VisiblePosition previous(startVisiblePos.previous()); |
| if (isEndOfLine(previous)) { |
| // On empty line |
| return VisibleSelection(); |
| } |
| UChar c(previous.characterAfter()); |
| if (isSpaceOrNewline(c) || c == noBreakSpace) { |
| // Space at end of line |
| return VisibleSelection(); |
| } |
| frameSelection.moveTo(startVisiblePos); |
| frameSelection.modify(FrameSelection::AlterationExtend, DirectionBackward, WordGranularity); |
| startPos = frameSelection.selection().start(); |
| endPos = frameSelection.selection().end(); |
| startVisiblePos = VisiblePosition(startPos, VP_DEFAULT_AFFINITY); |
| endVisiblePos = VisiblePosition(endPos, VP_DEFAULT_AFFINITY); |
| if (startVisiblePos.isNull() || endVisiblePos.isNull()) { |
| // Start or end is nil |
| return VisibleSelection(); |
| } |
| } |
| |
| // Now loop backwards until we find a non-space. |
| while (endVisiblePos != startVisiblePos) { |
| VisiblePosition previous(endVisiblePos.previous()); |
| UChar c(previous.characterAfter()); |
| if (!isSpaceOrNewline(c) && c != noBreakSpace) |
| break; |
| endVisiblePos = previous; |
| } |
| |
| // Expansion cannot be allowed to change selection so that it is no longer |
| // touches (or contains) the original, unexpanded selection. |
| // Enforce this on the way out of the function to preserve the invariant. |
| if (startVisiblePos > startVisiblePosBeforeExpansion) |
| startVisiblePos = startVisiblePosBeforeExpansion; |
| if (endVisiblePos < endVisiblePosBeforeExpansion) |
| endVisiblePos = endVisiblePosBeforeExpansion; |
| |
| return VisibleSelection(startVisiblePos, endVisiblePos); |
| } |
| |
| bool FrameSelection::actualSelectionAtSentenceStart(const VisibleSelection& sel) const |
| { |
| Position startPos(sel.start()); |
| VisiblePosition pos(createLegacyEditingPosition(startPos.deprecatedNode(), startPos.deprecatedEditingOffset()), VP_DEFAULT_AFFINITY); |
| if (pos.isNull()) |
| return false; |
| |
| if (isStartOfParagraph(pos)) |
| return true; |
| |
| bool result = true; |
| bool sawSpace = false; |
| unsigned previousCount = 0; |
| for (pos = pos.previous(); !pos.isNull(); pos = pos.previous()) { |
| previousCount++; |
| if (isStartOfParagraph(pos)) { |
| if (previousCount == 1 || (previousCount == 2 && sawSpace)) |
| result = false; |
| break; |
| } |
| UChar c(pos.characterAfter()); |
| if (c) { |
| if (isSpaceOrNewline(c) || c == noBreakSpace) { |
| sawSpace = true; |
| } |
| else { |
| result = (c == '.' || c == '!' || c == '?'); |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| RefPtr<Range> FrameSelection::rangeByAlteringCurrentSelection(EAlteration alteration, int amount) const |
| { |
| if (m_selection.isNone()) |
| return nullptr; |
| |
| if (!amount) |
| return toNormalizedRange(); |
| |
| FrameSelection frameSelection; |
| frameSelection.setSelection(m_selection); |
| SelectionDirection direction = amount > 0 ? DirectionForward : DirectionBackward; |
| for (int i = 0; i < abs(amount); i++) |
| frameSelection.modify(alteration, direction, CharacterGranularity); |
| return frameSelection.toNormalizedRange(); |
| } |
| |
| void FrameSelection::clearCurrentSelection() |
| { |
| setSelection(VisibleSelection()); |
| } |
| |
| void FrameSelection::setCaretBlinks(bool caretBlinks) |
| { |
| if (m_caretBlinks == caretBlinks) |
| return; |
| #if ENABLE(TEXT_CARET) |
| m_frame->document()->updateLayoutIgnorePendingStylesheets(); |
| if (m_caretPaint) { |
| m_caretPaint = false; |
| invalidateCaretRect(); |
| } |
| #endif |
| if (caretBlinks) |
| setFocusedElementIfNeeded(); |
| m_caretBlinks = caretBlinks; |
| updateAppearance(); |
| } |
| |
| void FrameSelection::setCaretColor(const Color& caretColor) |
| { |
| if (m_caretColor != caretColor) { |
| m_caretColor = caretColor; |
| if (caretIsVisible() && m_caretBlinks && isCaret()) |
| invalidateCaretRect(); |
| } |
| } |
| #endif // PLATFORM(IOS) |
| |
| } |
| |
| #if ENABLE(TREE_DEBUGGING) |
| |
| void showTree(const WebCore::FrameSelection& sel) |
| { |
| sel.showTreeForThis(); |
| } |
| |
| void showTree(const WebCore::FrameSelection* sel) |
| { |
| if (sel) |
| sel->showTreeForThis(); |
| } |
| |
| #endif |