blob: 24e287042a0188bd815c9f1468b0d64853aaae4b [file] [log] [blame]
/*
* Copyright (C) 2004-2020 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 "VisibleUnits.h"
#include "Document.h"
#include "Editing.h"
#include "HTMLBRElement.h"
#include "HTMLElement.h"
#include "HTMLNames.h"
#include "InlineIteratorBox.h"
#include "InlineIteratorLine.h"
#include "InlineIteratorLogicalOrderTraversal.h"
#include "InlineRunAndOffset.h"
#include "NodeTraversal.h"
#include "Range.h"
#include "RenderBlockFlow.h"
#include "RenderObject.h"
#include "RenderedPosition.h"
#include "Text.h"
#include "TextBoundaries.h"
#include "TextIterator.h"
#include "VisibleSelection.h"
#include <unicode/ubrk.h>
#include <wtf/text/TextBreakIterator.h>
namespace WebCore {
using namespace HTMLNames;
using namespace WTF::Unicode;
static Node* previousLeafWithSameEditability(Node* node, EditableType editableType)
{
bool editable = hasEditableStyle(*node, editableType);
node = previousLeafNode(node);
while (node) {
if (editable == hasEditableStyle(*node, editableType))
return node;
node = previousLeafNode(node);
}
return nullptr;
}
static Node* nextLeafWithSameEditability(Node* node, EditableType editableType)
{
if (!node)
return nullptr;
bool editable = hasEditableStyle(*node, editableType);
node = nextLeafNode(node);
while (node) {
if (editable == hasEditableStyle(*node, editableType))
return node;
node = nextLeafNode(node);
}
return nullptr;
}
// FIXME: consolidate with code in previousLinePosition.
static Position previousLineCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
{
auto* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
Node* previousNode = previousLeafWithSameEditability(node, editableType);
while (previousNode && (!previousNode->renderer() || inSameLine(firstPositionInOrBeforeNode(previousNode), visiblePosition)))
previousNode = previousLeafWithSameEditability(previousNode, editableType);
while (previousNode && !previousNode->isShadowRoot()) {
if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
break;
Position pos = previousNode->hasTagName(brTag) ? positionBeforeNode(previousNode) :
makeDeprecatedLegacyPosition(previousNode, caretMaxOffset(*previousNode));
if (pos.isCandidate())
return pos;
previousNode = previousLeafWithSameEditability(previousNode, editableType);
}
return Position();
}
static Position nextLineCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
{
auto* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
Node* nextNode = nextLeafWithSameEditability(node, editableType);
while (nextNode && (!nextNode->renderer() || inSameLine(firstPositionInOrBeforeNode(nextNode), visiblePosition)))
nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
while (nextNode && !nextNode->isShadowRoot()) {
if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
break;
Position pos;
pos = makeDeprecatedLegacyPosition(nextNode, caretMinOffset(*nextNode));
if (pos.isCandidate())
return pos;
nextNode = nextLeafWithSameEditability(nextNode, editableType);
}
return Position();
}
static bool isTextOrLineBreakRun(InlineIterator::LeafBoxIterator run)
{
return run && (run->isText() || run->renderer().isBR());
}
static InlineIterator::LeafBoxIterator previousTextOrLineBreakRun(InlineIterator::LeafBoxIterator run, InlineIterator::LineLogicalOrderCache& orderCache)
{
while (run) {
run = InlineIterator::previousLeafOnLineInLogicalOrder(run, orderCache);
if (isTextOrLineBreakRun(run))
return run;
}
return { };
}
static InlineIterator::LeafBoxIterator nextTextOrLineBreakRun(InlineIterator::LeafBoxIterator run, InlineIterator::LineLogicalOrderCache& orderCache)
{
while (run) {
run = InlineIterator::nextLeafOnLineInLogicalOrder(run, orderCache);
if (isTextOrLineBreakRun(run))
return run;
}
return { };
}
static InlineIterator::LeafBoxIterator startTextOrLineBreakRun(InlineIterator::LineIterator line, InlineIterator::LineLogicalOrderCache& orderCache)
{
auto run = InlineIterator::firstLeafOnLineInLogicalOrder(line, orderCache);
if (isTextOrLineBreakRun(run))
return run;
return nextTextOrLineBreakRun(run, orderCache);
}
static InlineIterator::LeafBoxIterator endTextOrLineBreakRun(InlineIterator::LineIterator line, InlineIterator::LineLogicalOrderCache& orderCache)
{
auto run = InlineIterator::lastLeafOnLineInLogicalOrder(line, orderCache);
if (isTextOrLineBreakRun(run))
return run;
return previousTextOrLineBreakRun(run, orderCache);
}
static const InlineIterator::LeafBoxIterator logicallyPreviousRun(const VisiblePosition& visiblePosition, InlineIterator::LeafBoxIterator startRun, InlineIterator::LineLogicalOrderCache& orderCache, bool& previousBoxInDifferentLine)
{
if (auto previousRun = previousTextOrLineBreakRun(startRun, orderCache))
return previousRun;
if (auto previousLine = startRun->line()->previous()) {
// FIXME: Why isn't previousBoxInDifferentLine set here?
if (auto previousRun = endTextOrLineBreakRun(previousLine, orderCache))
return previousRun;
}
while (1) {
auto* startNode = startRun->renderer().nonPseudoNode();
if (!startNode)
break;
Position position = previousLineCandidatePosition(startNode, visiblePosition, ContentIsEditable);
if (position.isNull())
break;
RenderedPosition renderedPosition(position, Affinity::Downstream);
auto previousLine = renderedPosition.line();
if (!previousLine)
break;
if (previousLine != startRun->line()) {
if (auto previousRun = endTextOrLineBreakRun(previousLine, orderCache)) {
previousBoxInDifferentLine = true;
return previousRun;
}
}
startRun = InlineIterator::firstLeafOnLineInLogicalOrder(previousLine, orderCache);
}
return { };
}
static const InlineIterator::LeafBoxIterator logicallyNextRun(const VisiblePosition& visiblePosition, InlineIterator::LeafBoxIterator startRun, InlineIterator::LineLogicalOrderCache& orderCache, bool& nextBoxInDifferentLine)
{
if (auto nextRun = nextTextOrLineBreakRun(startRun, orderCache))
return nextRun;
if (auto nextLine = startRun->line()->next()) {
// FIXME: Why isn't previousBoxInDifferentLine set here?
if (auto nextRun = startTextOrLineBreakRun(nextLine, orderCache))
return nextRun;
}
while (1) {
auto* startNode = startRun->renderer().nonPseudoNode();
if (!startNode)
break;
Position position = nextLineCandidatePosition(startNode, visiblePosition, ContentIsEditable);
if (position.isNull())
break;
RenderedPosition renderedPosition(position, Affinity::Downstream);
auto nextLine = renderedPosition.line();
if (!nextLine)
break;
if (nextLine != startRun->line()) {
if (auto nextRun = startTextOrLineBreakRun(nextLine, orderCache)) {
nextBoxInDifferentLine = true;
return nextRun;
}
}
startRun = InlineIterator::lastLeafOnLineInLogicalOrderWithNode(nextLine, orderCache);
}
return { };
}
static UBreakIterator* wordBreakIteratorForMinOffsetBoundary(const VisiblePosition& visiblePosition, InlineIterator::TextBoxIterator textRun,
unsigned& previousRunLength, bool& previousRunInDifferentLine, Vector<UChar, 1024>& string)
{
previousRunInDifferentLine = false;
InlineIterator::LineLogicalOrderCache orderCache;
auto previousRun = logicallyPreviousRun(visiblePosition, textRun, orderCache, previousRunInDifferentLine);
while (previousRun && !previousRun->isText()) {
ASSERT(previousRun->renderer().isBR());
previousRunInDifferentLine = true;
previousRun = logicallyPreviousRun(visiblePosition, previousRun, orderCache, previousRunInDifferentLine);
}
string.clear();
if (previousRun) {
auto& previousTextRun = downcast<InlineIterator::TextBoxIterator>(previousRun);
previousRunLength = previousTextRun->length();
append(string, previousTextRun->text());
}
append(string, textRun->text());
return wordBreakIterator(StringView(string.data(), string.size()));
}
static UBreakIterator* wordBreakIteratorForMaxOffsetBoundary(const VisiblePosition& visiblePosition, InlineIterator::TextBoxIterator textRun,
bool& nextRunInDifferentLine, Vector<UChar, 1024>& string)
{
nextRunInDifferentLine = false;
InlineIterator::LineLogicalOrderCache orderCache;
auto nextRun = logicallyNextRun(visiblePosition, textRun, orderCache, nextRunInDifferentLine);
while (nextRun && !nextRun->isText()) {
ASSERT(nextRun->renderer().isBR());
nextRunInDifferentLine = true;
nextRun = logicallyNextRun(visiblePosition, nextRun, orderCache, nextRunInDifferentLine);
}
string.clear();
append(string, textRun->text());
if (nextRun) {
auto& nextTextRun = downcast<InlineIterator::TextBoxIterator>(nextRun);
append(string, nextTextRun->text());
}
return wordBreakIterator(StringView(string.data(), string.size()));
}
static bool isLogicalStartOfWord(UBreakIterator* iter, int position, bool hardLineBreak)
{
bool boundary = hardLineBreak ? true : ubrk_isBoundary(iter, position);
if (!boundary)
return false;
ubrk_following(iter, position);
// isWordTextBreak returns true after moving across a word and false after moving across a punctuation/space.
return isWordTextBreak(iter);
}
static bool islogicalEndOfWord(UBreakIterator* iter, int position, bool hardLineBreak)
{
bool boundary = ubrk_isBoundary(iter, position);
return (hardLineBreak || boundary) && isWordTextBreak(iter);
}
enum CursorMovementDirection { MoveLeft, MoveRight };
static VisiblePosition visualWordPosition(const VisiblePosition& visiblePosition, CursorMovementDirection direction,
bool skipsSpaceWhenMovingRight)
{
if (visiblePosition.isNull() || !visiblePosition.deepEquivalent().document())
return VisiblePosition();
visiblePosition.deepEquivalent().document()->updateLayoutIgnorePendingStylesheets();
TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
InlineIterator::LeafBoxIterator previouslyVisitedRun;
VisiblePosition current = visiblePosition;
std::optional<VisiblePosition> previousPosition;
UBreakIterator* iter = nullptr;
Vector<UChar, 1024> string;
while (1) {
VisiblePosition adjacentCharacterPosition = direction == MoveRight ? current.right(true) : current.left(true);
if (adjacentCharacterPosition == current || adjacentCharacterPosition.isNull())
return VisiblePosition();
// FIXME: This is a workaround for webkit.org/b/167138.
if (previousPosition && adjacentCharacterPosition == previousPosition.value())
return VisiblePosition();
// FIXME: Why force the use of upstream affinity here instead of VisiblePosition::inlineRunAndOffset, which will get affinity from adjacentCharacterPosition?
auto [run, offsetInRun] = adjacentCharacterPosition.deepEquivalent().inlineRunAndOffset(Affinity::Upstream);
if (!run)
break;
if (!run->isText()) {
current = adjacentCharacterPosition;
continue;
}
auto& textRun = downcast<InlineIterator::TextBoxIterator>(run);
unsigned previousRunLength = 0;
bool previousRunInDifferentLine = false;
bool nextRunInDifferentLine = false;
bool movingIntoNewRun = previouslyVisitedRun != run;
if (offsetInRun == textRun->minimumCaretOffset())
iter = wordBreakIteratorForMinOffsetBoundary(adjacentCharacterPosition, textRun, previousRunLength, previousRunInDifferentLine, string);
else if (offsetInRun == textRun->maximumCaretOffset())
iter = wordBreakIteratorForMaxOffsetBoundary(adjacentCharacterPosition, textRun, nextRunInDifferentLine, string);
else if (movingIntoNewRun) {
iter = wordBreakIterator(textRun->text());
previouslyVisitedRun = run;
}
if (!iter)
break;
ubrk_first(iter);
int offsetInIterator = offsetInRun - textRun->start() + previousRunLength;
bool isWordBreak;
bool boxHasSameDirectionalityAsBlock = run->direction() == blockDirection;
bool movingBackward = (direction == MoveLeft && run->direction() == TextDirection::LTR) || (direction == MoveRight && run->direction() == TextDirection::RTL);
if ((skipsSpaceWhenMovingRight && boxHasSameDirectionalityAsBlock)
|| (!skipsSpaceWhenMovingRight && movingBackward)) {
bool logicalStartInRenderer = offsetInRun == textRun->start() && previousRunInDifferentLine;
isWordBreak = isLogicalStartOfWord(iter, offsetInIterator, logicalStartInRenderer);
if (isWordBreak && offsetInRun == run->maximumCaretOffset() && nextRunInDifferentLine)
isWordBreak = false;
} else {
bool logicalEndInRenderer = offsetInRun == textRun->end() && nextRunInDifferentLine;
isWordBreak = islogicalEndOfWord(iter, offsetInIterator, logicalEndInRenderer);
if (isWordBreak && offsetInRun == run->minimumCaretOffset() && previousRunInDifferentLine)
isWordBreak = false;
}
if (isWordBreak)
return adjacentCharacterPosition;
previousPosition = current;
current = adjacentCharacterPosition;
}
return VisiblePosition();
}
VisiblePosition leftWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
{
VisiblePosition leftWordBreak = visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
leftWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(leftWordBreak);
// FIXME: How should we handle a non-editable position?
if (leftWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
leftWordBreak = blockDirection == TextDirection::LTR ? startOfEditableContent(visiblePosition) : endOfEditableContent(visiblePosition);
}
return leftWordBreak;
}
VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
{
VisiblePosition rightWordBreak = visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
rightWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(rightWordBreak);
// FIXME: How should we handle a non-editable position?
if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
rightWordBreak = blockDirection == TextDirection::LTR ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
}
return rightWordBreak;
}
static void prepend(Vector<UChar, 1024>& buffer, StringView string)
{
unsigned oldSize = buffer.size();
unsigned length = string.length();
buffer.grow(oldSize + length);
memmove(buffer.data() + length, buffer.data(), oldSize * sizeof(UChar));
for (unsigned i = 0; i < length; ++i)
buffer[i] = string[i];
}
static void prependRepeatedCharacter(Vector<UChar, 1024>& buffer, UChar character, unsigned count)
{
unsigned oldSize = buffer.size();
buffer.grow(oldSize + count);
memmove(buffer.data() + count, buffer.data(), oldSize * sizeof(UChar));
for (unsigned i = 0; i < count; ++i)
buffer[i] = character;
}
static void appendRepeatedCharacter(Vector<UChar, 1024>& buffer, UChar character, unsigned count)
{
unsigned oldSize = buffer.size();
buffer.grow(oldSize + count);
for (unsigned i = 0; i < count; ++i)
buffer[oldSize + i] = character;
}
unsigned suffixLengthForRange(const SimpleRange& forwardsScanRange, Vector<UChar, 1024>& string)
{
unsigned suffixLength = 0;
TextIterator forwardsIterator(forwardsScanRange);
while (!forwardsIterator.atEnd()) {
StringView text = forwardsIterator.text();
unsigned i = endOfFirstWordBoundaryContext(text);
append(string, text.substring(0, i));
suffixLength += i;
if (i < text.length())
break;
forwardsIterator.advance();
}
return suffixLength;
}
unsigned prefixLengthForRange(const SimpleRange& backwardsScanRange, Vector<UChar, 1024>& string)
{
unsigned prefixLength = 0;
SimplifiedBackwardsTextIterator backwardsIterator(backwardsScanRange);
while (!backwardsIterator.atEnd()) {
StringView text = backwardsIterator.text();
int i = startOfLastWordBoundaryContext(text);
prepend(string, text.substring(i));
prefixLength += text.length() - i;
if (i > 0)
break;
backwardsIterator.advance();
}
return prefixLength;
}
unsigned backwardSearchForBoundaryWithTextIterator(SimplifiedBackwardsTextIterator& it, Vector<UChar, 1024>& string, unsigned suffixLength, BoundarySearchFunction searchFunction)
{
unsigned next = 0;
bool needMoreContext = false;
while (!it.atEnd()) {
bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TextSecurity::None;
// iterate to get chunks until the searchFunction returns a non-zero value.
if (!inTextSecurityMode)
prepend(string, it.text());
else {
// Treat bullets used in the text security mode as regular characters when looking for boundaries
prependRepeatedCharacter(string, 'x', it.text().length());
}
if (string.size() > suffixLength) {
next = searchFunction(StringView(string.data(), string.size()), string.size() - suffixLength, MayHaveMoreContext, needMoreContext);
if (next > 1) // FIXME: This is a work around for https://webkit.org/b/115070. We need to provide more contexts in general case.
break;
}
it.advance();
}
if (needMoreContext && string.size() > suffixLength) {
// The last search returned the beginning of the buffer and asked for more context,
// but there is no earlier text. Force a search with what's available.
next = searchFunction(StringView(string.data(), string.size()), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
ASSERT(!needMoreContext);
}
return next;
}
unsigned forwardSearchForBoundaryWithTextIterator(TextIterator& it, Vector<UChar, 1024>& string, unsigned prefixLength, BoundarySearchFunction searchFunction)
{
unsigned next = 0;
bool needMoreContext = false;
while (!it.atEnd()) {
bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TextSecurity::None;
// Keep asking the iterator for chunks until the search function
// returns an end value not equal to the length of the string passed to it.
if (!inTextSecurityMode)
append(string, it.text());
else {
// Treat bullets used in the text security mode as regular characters when looking for boundaries
appendRepeatedCharacter(string, 'x', it.text().length());
}
if (string.size() > prefixLength) {
next = searchFunction(StringView(string.data(), string.size()), prefixLength, MayHaveMoreContext, needMoreContext);
if (next != string.size())
break;
}
it.advance();
}
if (needMoreContext && string.size() > prefixLength) {
// The last search returned the end of the buffer and asked for more context,
// but there is no further text. Force a search with what's available.
next = searchFunction(StringView(string.data(), string.size()), prefixLength, DontHaveMoreContext, needMoreContext);
ASSERT(!needMoreContext);
}
return next;
}
enum class NeedsContextAtParagraphStart { Yes, No };
static VisiblePosition previousBoundary(const VisiblePosition& position, BoundarySearchFunction searchFunction,
NeedsContextAtParagraphStart needsContextAtParagraphStart = NeedsContextAtParagraphStart::No)
{
auto boundary = position.deepEquivalent().parentEditingBoundary();
if (!boundary)
return { };
Vector<UChar, 1024> string;
unsigned suffixLength = 0;
auto searchRange = makeSimpleRange(makeBoundaryPointBeforeNodeContents(*boundary), position);
if (!searchRange)
return { };
if (needsContextAtParagraphStart == NeedsContextAtParagraphStart::Yes && isStartOfParagraph(position)) {
auto forwardsScanRange = makeSimpleRange(searchRange->start, endOfParagraph(position));
if (!forwardsScanRange)
return { };
for (TextIterator forwardsIterator(*forwardsScanRange); !forwardsIterator.atEnd(); forwardsIterator.advance())
append(string, forwardsIterator.text());
suffixLength = string.size();
} else if (requiresContextForWordBoundary(position.characterBefore())) {
auto forwardsScanRange = makeSimpleRange(searchRange->end, makeBoundaryPointAfterNodeContents(*boundary));
suffixLength = suffixLengthForRange(forwardsScanRange, string);
}
SimplifiedBackwardsTextIterator it(*searchRange);
unsigned next = backwardSearchForBoundaryWithTextIterator(it, string, suffixLength, searchFunction);
if (!next)
return it.atEnd() ? makeDeprecatedLegacyPosition(searchRange->start) : position;
auto& node = (it.atEnd() ? *searchRange : it.range()).start.container.get();
if ((!suffixLength && is<Text>(node) && next <= downcast<Text>(node).length()) || (node.renderer() && node.renderer()->isBR() && !next)) {
// The next variable contains a usable index into a text node.
return makeDeprecatedLegacyPosition(&node, next);
}
// Use the character iterator to translate the next value into a DOM position.
BackwardsCharacterIterator charIt(*searchRange);
if (next < string.size() - suffixLength)
charIt.advance(string.size() - suffixLength - next);
// FIXME: charIt can get out of shadow host.
return makeDeprecatedLegacyPosition(charIt.range().end);
}
static VisiblePosition nextBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
{
Position pos = c.deepEquivalent();
Node* boundary = pos.parentEditingBoundary();
if (!boundary)
return VisiblePosition();
Document& boundaryDocument = boundary->document();
Vector<UChar, 1024> string;
unsigned prefixLength = 0;
if (requiresContextForWordBoundary(c.characterAfter())) {
auto backwardsScanRange = makeSimpleRange(makeBoundaryPointBeforeNodeContents(boundaryDocument), c);
if (!backwardsScanRange)
return { };
prefixLength = prefixLengthForRange(*backwardsScanRange, string);
}
auto searchRange = makeSimpleRange(c, makeBoundaryPointAfterNodeContents(*boundary));
if (!searchRange)
return { };
TextIterator it(*searchRange, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);
unsigned next = forwardSearchForBoundaryWithTextIterator(it, string, prefixLength, searchFunction);
if (it.atEnd() && next == string.size())
pos = makeDeprecatedLegacyPosition(searchRange->end);
else if (next > prefixLength) {
// Use the character iterator to translate the next value into a DOM position.
CharacterIterator charIt(*searchRange, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);
charIt.advance(next - prefixLength - 1);
if (charIt.atEnd())
return { };
auto characterRange = charIt.range();
pos = makeDeprecatedLegacyPosition(characterRange.end);
if (charIt.text()[0] == '\n') {
// FIXME: workaround for collapsed range (where only start position is correct) emitted for some emitted newlines (see rdar://5192593)
if (VisiblePosition(pos) == VisiblePosition(makeDeprecatedLegacyPosition(characterRange.start))) {
charIt.advance(1);
pos = makeDeprecatedLegacyPosition(charIt.range().start);
}
}
}
return VisiblePosition(pos, Affinity::Upstream);
}
// ---------
unsigned startWordBoundary(StringView text, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
{
ASSERT(offset);
if (mayHaveMoreContext && !startOfLastWordBoundaryContext(text.substring(0, offset))) {
needMoreContext = true;
return 0;
}
needMoreContext = false;
int start, end;
U16_BACK_1(text, 0, offset);
findWordBoundary(text, offset, &start, &end);
return start;
}
VisiblePosition startOfWord(const VisiblePosition& c, EWordSide side)
{
// FIXME: This returns a null VP for c at the start of the document
// and side == LeftWordIfOnBoundary
VisiblePosition p = c;
if (side == RightWordIfOnBoundary) {
// at paragraph end, the startofWord is the current position
if (isEndOfParagraph(c))
return c;
p = c.next();
if (p.isNull())
return c;
}
return previousBoundary(p, startWordBoundary);
}
unsigned endWordBoundary(StringView text, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
{
ASSERT(offset <= text.length());
if (mayHaveMoreContext && endOfFirstWordBoundaryContext(text.substring(offset)) == text.length() - offset) {
needMoreContext = true;
return text.length();
}
needMoreContext = false;
int end;
findEndWordBoundary(text, offset, &end);
return end;
}
VisiblePosition endOfWord(const VisiblePosition& c, EWordSide side)
{
VisiblePosition p = c;
if (side == LeftWordIfOnBoundary) {
if (isStartOfParagraph(c))
return c;
p = c.previous();
if (p.isNull())
return c;
} else if (isEndOfParagraph(c))
return c;
return nextBoundary(p, endWordBoundary);
}
static unsigned previousWordPositionBoundary(StringView text, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
{
if (mayHaveMoreContext && !startOfLastWordBoundaryContext(text.substring(0, offset))) {
needMoreContext = true;
return 0;
}
needMoreContext = false;
return findNextWordFromIndex(text, offset, false);
}
VisiblePosition previousWordPosition(const VisiblePosition& position)
{
return position.honorEditingBoundaryAtOrBefore(previousBoundary(position, previousWordPositionBoundary));
}
static unsigned nextWordPositionBoundary(StringView text, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
{
if (mayHaveMoreContext && endOfFirstWordBoundaryContext(text.substring(offset)) == text.length() - offset) {
needMoreContext = true;
return text.length();
}
needMoreContext = false;
return findNextWordFromIndex(text, offset, true);
}
VisiblePosition nextWordPosition(const VisiblePosition& position)
{
return position.honorEditingBoundaryAtOrAfter(nextBoundary(position, nextWordPositionBoundary));
}
bool isStartOfWord(const VisiblePosition& p)
{
return p.isNotNull() && p == startOfWord(p, RightWordIfOnBoundary);
}
// ---------
enum LineEndpointComputationMode { UseLogicalOrdering, UseInlineBoxOrdering };
static VisiblePosition startPositionForLine(const VisiblePosition& c, LineEndpointComputationMode mode)
{
if (c.isNull())
return VisiblePosition();
auto line = RenderedPosition(c).line();
if (!line) {
// There are VisiblePositions at offset 0 in blocks without
// RootInlineBoxes, like empty editable blocks and bordered blocks.
Position p = c.deepEquivalent();
if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
return c;
return VisiblePosition();
}
InlineIterator::LineLogicalOrderCache orderCache;
Node* startNode = nullptr;
auto startRun = mode == UseLogicalOrdering ? InlineIterator::firstLeafOnLineInLogicalOrderWithNode(line, orderCache) : line->firstLeafBox();
// Generated content (e.g. list markers and CSS :before and :after pseudoelements) have no corresponding DOM element,
// and so cannot be represented by a VisiblePosition. Use whatever follows instead.
while (true) {
if (!startRun)
return VisiblePosition();
startNode = startRun->renderer().nonPseudoNode();
if (startNode)
break;
if (mode == UseLogicalOrdering)
startRun = InlineIterator::nextLeafOnLineInLogicalOrder(startRun, orderCache);
else
startRun.traverseNextOnLine();
}
return is<Text>(*startNode) ? Position(downcast<Text>(startNode), downcast<InlineIterator::TextBox>(*startRun).start())
: positionBeforeNode(startNode);
}
static VisiblePosition startOfLine(const VisiblePosition& c, LineEndpointComputationMode mode, bool* reachedBoundary)
{
if (reachedBoundary)
*reachedBoundary = false;
// TODO: this is the current behavior that might need to be fixed.
// Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
VisiblePosition visPos = startPositionForLine(c, mode);
if (mode == UseLogicalOrdering) {
if (Node* editableRoot = highestEditableRoot(c.deepEquivalent())) {
if (!editableRoot->contains(visPos.deepEquivalent().containerNode())) {
VisiblePosition newPosition = firstPositionInNode(editableRoot);
if (reachedBoundary)
*reachedBoundary = c == newPosition;
return newPosition;
}
}
}
return c.honorEditingBoundaryAtOrBefore(visPos, reachedBoundary);
}
// FIXME: Rename this function to reflect the fact it ignores bidi levels.
VisiblePosition startOfLine(const VisiblePosition& currentPosition)
{
return startOfLine(currentPosition, UseInlineBoxOrdering, nullptr);
}
VisiblePosition logicalStartOfLine(const VisiblePosition& currentPosition, bool* reachedBoundary)
{
return startOfLine(currentPosition, UseLogicalOrdering, reachedBoundary);
}
static VisiblePosition endPositionForLine(const VisiblePosition& c, LineEndpointComputationMode mode)
{
if (c.isNull())
return VisiblePosition();
auto line = RenderedPosition(c).line();
if (!line) {
// There are VisiblePositions at offset 0 in blocks without
// RootInlineBoxes, like empty editable blocks and bordered blocks.
Position p = c.deepEquivalent();
if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
return c;
return VisiblePosition();
}
InlineIterator::LineLogicalOrderCache orderCache;
Node* endNode = nullptr;
auto endRun = mode == UseLogicalOrdering ? InlineIterator::lastLeafOnLineInLogicalOrder(line, orderCache) : line->lastLeafBox();
// Generated content (e.g. list markers and CSS :before and :after pseudoelements) have no corresponding DOM element,
// and so cannot be represented by a VisiblePosition. Use whatever precedes instead.
while (true) {
if (!endRun)
return VisiblePosition();
endNode = endRun->renderer().nonPseudoNode();
if (endNode)
break;
if (mode == UseLogicalOrdering)
endRun = InlineIterator::previousLeafOnLineInLogicalOrder(endRun, orderCache);
else
endRun.traversePreviousOnLine();
}
Position pos;
if (is<HTMLBRElement>(*endNode))
pos = positionBeforeNode(endNode);
else if (is<InlineIterator::TextBox>(*endRun) && is<Text>(*endNode)) {
auto& endTextRun = downcast<InlineIterator::TextBox>(*endRun);
int endOffset = endTextRun.start();
if (!endTextRun.isLineBreak())
endOffset += endTextRun.length();
pos = Position(downcast<Text>(endNode), endOffset);
} else
pos = positionAfterNode(endNode);
return VisiblePosition(pos, Affinity::Upstream);
}
static bool inSameLogicalLine(const VisiblePosition& a, const VisiblePosition& b)
{
return a.isNotNull() && logicalStartOfLine(a) == logicalStartOfLine(b);
}
static VisiblePosition endOfLine(const VisiblePosition& c, LineEndpointComputationMode mode, bool* reachedBoundary)
{
if (reachedBoundary)
*reachedBoundary = false;
// TODO: this is the current behavior that might need to be fixed.
// Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
VisiblePosition visPos = endPositionForLine(c, mode);
if (mode == UseLogicalOrdering) {
// Make sure the end of line is at the same line as the given input position. For a wrapping line, the logical end
// position for the not-last-2-lines might incorrectly hand back the logical beginning of the next line.
// For example, <div contenteditable dir="rtl" style="line-break:before-white-space">abcdefg abcdefg abcdefg
// a abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg </div>
// In this case, use the previous position of the computed logical end position.
if (!inSameLogicalLine(c, visPos))
visPos = visPos.previous();
if (Node* editableRoot = highestEditableRoot(c.deepEquivalent())) {
if (!editableRoot->contains(visPos.deepEquivalent().containerNode())) {
VisiblePosition newPosition = lastPositionInNode(editableRoot);
if (reachedBoundary)
*reachedBoundary = c == newPosition;
return newPosition;
}
}
return c.honorEditingBoundaryAtOrAfter(visPos, reachedBoundary);
}
// Make sure the end of line is at the same line as the given input position. Else use the previous position to
// obtain end of line. This condition happens when the input position is before the space character at the end
// of a soft-wrapped non-editable line. In this scenario, endPositionForLine would incorrectly hand back a position
// in the next line instead. This fix is to account for the discrepancy between lines with webkit-line-break:after-white-space style
// versus lines without that style, which would break before a space by default.
if (!inSameLine(c, visPos)) {
visPos = c.previous();
if (visPos.isNull())
return VisiblePosition();
visPos = endPositionForLine(visPos, UseInlineBoxOrdering);
}
return c.honorEditingBoundaryAtOrAfter(visPos, reachedBoundary);
}
// FIXME: Rename this function to reflect the fact it ignores bidi levels.
VisiblePosition endOfLine(const VisiblePosition& currentPosition)
{
return endOfLine(currentPosition, UseInlineBoxOrdering, nullptr);
}
VisiblePosition logicalEndOfLine(const VisiblePosition& currentPosition, bool* reachedBoundary)
{
return endOfLine(currentPosition, UseLogicalOrdering, reachedBoundary);
}
bool inSameLine(const VisiblePosition& a, const VisiblePosition& b)
{
return a.isNotNull() && startOfLine(a) == startOfLine(b);
}
bool isStartOfLine(const VisiblePosition& p)
{
return p.isNotNull() && p == startOfLine(p);
}
bool isEndOfLine(const VisiblePosition& p)
{
return p.isNotNull() && p == endOfLine(p);
}
bool isLogicalEndOfLine(const VisiblePosition& p)
{
return p.isNotNull() && p == logicalEndOfLine(p);
}
static inline IntPoint absoluteLineDirectionPointToLocalPointInBlock(InlineIterator::LineIterator& line, int lineDirectionPoint)
{
auto& containingBlock = line->containingBlock();
FloatPoint absoluteBlockPoint = containingBlock.localToAbsolute(FloatPoint()) - toFloatSize(containingBlock.scrollPosition());
if (containingBlock.isHorizontalWritingMode())
return IntPoint(lineDirectionPoint - absoluteBlockPoint.x(), line->blockDirectionPointInLine());
return IntPoint(line->blockDirectionPointInLine(), lineDirectionPoint - absoluteBlockPoint.y());
}
static Element* rootEditableOrDocumentElement(Node& node, EditableType editableType)
{
if (hasEditableStyle(node, editableType))
return editableRootForPosition(firstPositionInOrBeforeNode(&node), editableType);
return node.document().documentElement();
}
VisiblePosition previousLinePosition(const VisiblePosition& visiblePosition, int lineDirectionPoint, EditableType editableType)
{
Position p = visiblePosition.deepEquivalent();
Node* node = p.deprecatedNode();
if (!node)
return VisiblePosition();
node->document().updateLayoutIgnorePendingStylesheets();
RenderObject* renderer = node->renderer();
if (!renderer)
return VisiblePosition();
InlineIterator::LineIterator line;
if (auto run = visiblePosition.inlineRunAndOffset().run) {
line = run->line()->previous();
// We want to skip zero height boxes.
// This could happen in case it is a LegacyRootInlineBox with trailing floats.
if (!line || !line->logicalHeight() || !line->firstLeafBox())
line = { };
}
if (!line) {
Position position = previousLineCandidatePosition(node, visiblePosition, editableType);
if (position.isNotNull()) {
RenderedPosition renderedPosition(position);
line = renderedPosition.line();
if (!line)
return position;
}
}
if (line) {
// FIXME: Can be wrong for multi-column layout and with transforms.
auto pointInLine = absoluteLineDirectionPointToLocalPointInBlock(line, lineDirectionPoint);
auto run = line->closestRunForPoint(pointInLine, isEditablePosition(p));
if (!run)
return VisiblePosition();
auto& renderer = run->renderer();
Node* node = renderer.node();
if (node && editingIgnoresContent(*node))
return positionInParentBeforeNode(node);
return const_cast<RenderObject&>(renderer).positionForPoint(pointInLine, nullptr);
}
// Could not find a previous line. This means we must already be on the first line.
// Move to the start of the content in this block, which effectively moves us
// to the start of the line we're on.
Element* rootElement = rootEditableOrDocumentElement(*node, editableType);
if (!rootElement)
return VisiblePosition();
return firstPositionInNode(rootElement);
}
VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, int lineDirectionPoint, EditableType editableType)
{
Position p = visiblePosition.deepEquivalent();
Node* node = p.deprecatedNode();
if (!node)
return VisiblePosition();
node->document().updateLayoutIgnorePendingStylesheets();
if (!node->renderer())
return VisiblePosition();
InlineIterator::LineIterator line;
if (auto run = visiblePosition.inlineRunAndOffset().run) {
line = run->line()->next();
// We want to skip zero height boxes.
// This could happen in case it is a LegacyRootInlineBox with trailing floats.
if (!line || !line->logicalHeight() || !line->firstLeafBox())
line = { };
}
if (!line) {
// FIXME: We need do the same in previousLinePosition.
Node* child = node->traverseToChildAt(p.deprecatedEditingOffset());
node = child ? child : node->lastDescendant();
Position position = nextLineCandidatePosition(node, visiblePosition, editableType);
if (position.isNotNull()) {
RenderedPosition renderedPosition(position);
line = renderedPosition.line();
if (!line)
return position;
}
}
if (line) {
// FIXME: Can be wrong for multi-column layout and with transforms.
auto pointInLine = absoluteLineDirectionPointToLocalPointInBlock(line, lineDirectionPoint);
auto run = line->closestRunForPoint(pointInLine, isEditablePosition(p));
if (!run)
return VisiblePosition();
auto& renderer = run->renderer();
Node* node = renderer.node();
if (node && editingIgnoresContent(*node))
return positionInParentBeforeNode(node);
return const_cast<RenderObject&>(renderer).positionForPoint(pointInLine, nullptr);
}
// Could not find a next line. This means we must already be on the last line.
// Move to the end of the content in this block, which effectively moves us
// to the end of the line we're on.
Element* rootElement = rootEditableOrDocumentElement(*node, editableType);
if (!rootElement)
return VisiblePosition();
return lastPositionInNode(rootElement);
}
// ---------
unsigned startSentenceBoundary(StringView text, unsigned, BoundarySearchContextAvailability, bool&)
{
// FIXME: The following function can return -1; we don't handle that.
return ubrk_preceding(sentenceBreakIterator(text), text.length());
}
VisiblePosition startOfSentence(const VisiblePosition& position)
{
return previousBoundary(position, startSentenceBoundary, NeedsContextAtParagraphStart::Yes);
}
unsigned endSentenceBoundary(StringView text, unsigned, BoundarySearchContextAvailability, bool&)
{
return ubrk_next(sentenceBreakIterator(text));
}
VisiblePosition endOfSentence(const VisiblePosition& position)
{
// FIXME: This includes the space after the punctuation that marks the end of the sentence.
return nextBoundary(position, endSentenceBoundary);
}
static unsigned previousSentencePositionBoundary(StringView text, unsigned, BoundarySearchContextAvailability, bool&)
{
// FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's not right.
// FIXME: The following function can return -1; we don't handle that.
return ubrk_preceding(sentenceBreakIterator(text), text.length());
}
VisiblePosition previousSentencePosition(const VisiblePosition& position)
{
return position.honorEditingBoundaryAtOrBefore(previousBoundary(position, previousSentencePositionBoundary));
}
static unsigned nextSentencePositionBoundary(StringView text, unsigned, BoundarySearchContextAvailability, bool&)
{
// FIXME: This is identical to endSentenceBoundary.
// That isn't right. This function needs to move to the equivalent position in the following sentence.
return ubrk_following(sentenceBreakIterator(text), 0);
}
VisiblePosition nextSentencePosition(const VisiblePosition& position)
{
return position.honorEditingBoundaryAtOrAfter(nextBoundary(position, nextSentencePositionBoundary));
}
Node* findStartOfParagraph(Node* startNode, Node* highestRoot, Node* startBlock, int& offset, Position::AnchorType& type, EditingBoundaryCrossingRule boundaryCrossingRule)
{
Node* node = startNode;
Node* n = startNode;
while (n) {
if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNode->hasEditableStyle())
break;
if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
n = NodeTraversal::previousPostOrder(*n, startBlock);
if (!n || !n->isDescendantOf(highestRoot))
break;
}
RenderObject* r = n->renderer();
if (!r) {
n = NodeTraversal::previousPostOrder(*n, startBlock);
continue;
}
const RenderStyle& style = r->style();
if (style.visibility() != Visibility::Visible) {
n = NodeTraversal::previousPostOrder(*n, startBlock);
continue;
}
if (r->isBR() || isBlock(n))
break;
if (is<RenderText>(*r) && downcast<RenderText>(*r).hasRenderedText()) {
ASSERT_WITH_SECURITY_IMPLICATION(is<Text>(*n));
type = Position::PositionIsOffsetInAnchor;
if (style.preserveNewline()) {
StringImpl& text = downcast<RenderText>(*r).text();
int i = text.length();
int o = offset;
if (n == startNode && o < i)
i = std::max(0, o);
while (--i >= 0) {
if (text[i] == '\n') {
offset = i + 1;
return n;
}
}
}
node = n;
offset = 0;
n = NodeTraversal::previousPostOrder(*n, startBlock);
} else if (editingIgnoresContent(*n) || isRenderedTable(n)) {
node = n;
type = Position::PositionIsBeforeAnchor;
n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(*n, startBlock);
} else
n = NodeTraversal::previousPostOrder(*n, startBlock);
}
return node;
}
Node* findEndOfParagraph(Node* startNode, Node* highestRoot, Node* stayInsideBlock, int& offset, Position::AnchorType& type, EditingBoundaryCrossingRule boundaryCrossingRule)
{
Node* node = startNode;
Node* n = startNode;
while (n) {
if (boundaryCrossingRule == CannotCrossEditingBoundary && !Position::nodeIsUserSelectAll(n) && n->hasEditableStyle() != startNode->hasEditableStyle())
break;
if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
n = NodeTraversal::next(*n, stayInsideBlock);
if (!n || !n->isDescendantOf(highestRoot))
break;
}
RenderObject* r = n->renderer();
if (!r) {
n = NodeTraversal::next(*n, stayInsideBlock);
continue;
}
const RenderStyle& style = r->style();
if (style.visibility() != Visibility::Visible) {
n = NodeTraversal::next(*n, stayInsideBlock);
continue;
}
// FIXME: This is wrong when startNode is a block. We should return a position after the block.
if (r->isBR() || is<HTMLBRElement>(n) || isBlock(n))
break;
// FIXME: We avoid returning a position where the renderer can't accept the caret.
if (is<RenderText>(*r) && downcast<RenderText>(*r).hasRenderedText()) {
ASSERT_WITH_SECURITY_IMPLICATION(is<Text>(*n));
type = Position::PositionIsOffsetInAnchor;
if (style.preserveNewline()) {
StringImpl& text = downcast<RenderText>(*r).text();
int o = n == startNode ? offset : 0;
int length = text.length();
for (int i = o; i < length; ++i) {
if (text[i] == '\n') {
offset = i;
return n;
}
}
}
node = n;
offset = r->caretMaxOffset();
n = NodeTraversal::next(*n, stayInsideBlock);
} else if (editingIgnoresContent(*n) || isRenderedTable(n)) {
node = n;
type = Position::PositionIsAfterAnchor;
n = NodeTraversal::nextSkippingChildren(*n, stayInsideBlock);
} else
n = NodeTraversal::next(*n, stayInsideBlock);
}
return node;
}
VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
{
Position p = c.deepEquivalent();
auto* startNode = p.deprecatedNode();
if (!startNode)
return VisiblePosition();
if (isRenderedAsNonInlineTableImageOrHR(startNode))
return positionBeforeNode(startNode);
Node* startBlock = enclosingBlock(startNode);
auto* highestRoot = highestEditableRoot(p);
int offset = p.deprecatedEditingOffset();
Position::AnchorType type = p.anchorType();
auto* node = findStartOfParagraph(startNode, highestRoot, startBlock, offset, type, boundaryCrossingRule);
if (is<Text>(node))
return Position(downcast<Text>(node), offset);
if (type == Position::PositionIsOffsetInAnchor) {
ASSERT(type == Position::PositionIsOffsetInAnchor || !offset);
return Position(node, offset, type);
}
return Position(node, type);
}
VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
{
if (c.isNull())
return VisiblePosition();
Position p = c.deepEquivalent();
auto* startNode = p.deprecatedNode();
if (isRenderedAsNonInlineTableImageOrHR(startNode))
return positionAfterNode(startNode);
auto* startBlock = enclosingBlock(startNode);
auto* stayInsideBlock = startBlock;
auto* highestRoot = highestEditableRoot(p);
int offset = p.deprecatedEditingOffset();
Position::AnchorType type = p.anchorType();
auto* node = findEndOfParagraph(startNode, highestRoot, stayInsideBlock, offset, type, boundaryCrossingRule);
if (is<Text>(node))
return Position(downcast<Text>(node), offset);
if (type == Position::PositionIsOffsetInAnchor)
return Position(node, offset, type);
return Position(node, type);
}
// FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
{
VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
VisiblePosition afterParagraphEnd(paragraphEnd.next(CannotCrossEditingBoundary));
// The position after the last position in the last cell of a table
// is not the start of the next paragraph.
if (isFirstPositionAfterTable(afterParagraphEnd))
return afterParagraphEnd.next(CannotCrossEditingBoundary);
return afterParagraphEnd;
}
bool inSameParagraph(const VisiblePosition& a, const VisiblePosition& b, EditingBoundaryCrossingRule boundaryCrossingRule)
{
return a.isNotNull() && startOfParagraph(a, boundaryCrossingRule) == startOfParagraph(b, boundaryCrossingRule);
}
bool isStartOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
{
return pos.isNotNull() && pos == startOfParagraph(pos, boundaryCrossingRule);
}
bool isEndOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
{
return pos.isNotNull() && pos == endOfParagraph(pos, boundaryCrossingRule);
}
bool isBlankParagraph(const VisiblePosition& position)
{
return isStartOfParagraph(position) && startOfParagraph(position.next()) != startOfParagraph(position);
}
VisiblePosition previousParagraphPosition(const VisiblePosition& p, int x)
{
VisiblePosition pos = p;
do {
VisiblePosition n = previousLinePosition(pos, x);
if (n.isNull() || n == pos)
break;
pos = n;
} while (inSameParagraph(p, pos));
return pos;
}
VisiblePosition nextParagraphPosition(const VisiblePosition& p, int x)
{
VisiblePosition pos = p;
do {
VisiblePosition n = nextLinePosition(pos, x);
if (n.isNull() || n == pos)
break;
pos = n;
} while (inSameParagraph(p, pos));
return pos;
}
// ---------
VisiblePosition startOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
{
Position position = visiblePosition.deepEquivalent();
Node* startBlock;
if (!position.containerNode() || !(startBlock = enclosingBlock(position.containerNode(), rule)))
return VisiblePosition();
return firstPositionInNode(startBlock);
}
VisiblePosition endOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
{
Position position = visiblePosition.deepEquivalent();
Node* endBlock;
if (!position.containerNode() || !(endBlock = enclosingBlock(position.containerNode(), rule)))
return VisiblePosition();
return lastPositionInNode(endBlock);
}
bool inSameBlock(const VisiblePosition& a, const VisiblePosition& b)
{
return !a.isNull() && enclosingBlock(a.deepEquivalent().containerNode()) == enclosingBlock(b.deepEquivalent().containerNode());
}
bool isStartOfBlock(const VisiblePosition& pos)
{
return pos.isNotNull() && pos == startOfBlock(pos, CanCrossEditingBoundary);
}
bool isEndOfBlock(const VisiblePosition& pos)
{
return pos.isNotNull() && pos == endOfBlock(pos, CanCrossEditingBoundary);
}
// ---------
VisiblePosition startOfDocument(const Node* node)
{
if (!node || !node->document().documentElement())
return VisiblePosition();
// The canonicalization of the position at (documentElement, 0) can turn the visible
// position to null, even when there's a valid candidate to be had, because the root HTML element
// is not content editable. So we construct directly from the valid candidate.
Position firstCandidate = nextCandidate(makeDeprecatedLegacyPosition(node->document().documentElement(), 0));
if (firstCandidate.isNull())
return VisiblePosition();
return VisiblePosition(firstCandidate);
}
VisiblePosition startOfDocument(const VisiblePosition& c)
{
return startOfDocument(c.deepEquivalent().deprecatedNode());
}
VisiblePosition endOfDocument(const Node* node)
{
if (!node || !node->document().documentElement())
return VisiblePosition();
// (As above, in startOfDocument.) The canonicalization can reject valid visible positions
// when descending from the root element, so we construct the visible position directly from a
// valid candidate.
Position lastPosition = makeDeprecatedLegacyPosition(node->document().documentElement(), node->document().documentElement()->countChildNodes());
Position lastCandidate = previousCandidate(lastPosition);
if (lastCandidate.isNull())
return VisiblePosition();
return VisiblePosition(lastCandidate);
}
VisiblePosition endOfDocument(const VisiblePosition& c)
{
return endOfDocument(c.deepEquivalent().deprecatedNode());
}
bool inSameDocument(const VisiblePosition& a, const VisiblePosition& b)
{
Position ap = a.deepEquivalent();
Node* an = ap.deprecatedNode();
if (!an)
return false;
Position bp = b.deepEquivalent();
Node* bn = bp.deprecatedNode();
if (an == bn)
return true;
return &an->document() == &bn->document();
}
bool isStartOfDocument(const VisiblePosition& p)
{
return p.isNotNull() && p.previous(CanCrossEditingBoundary).isNull();
}
bool isEndOfDocument(const VisiblePosition& p)
{
return p.isNotNull() && p.next(CanCrossEditingBoundary).isNull();
}
// ---------
VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
{
auto* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
if (!highestRoot)
return { };
return firstPositionInNode(highestRoot);
}
VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
{
auto* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
if (!highestRoot)
return { };
return lastPositionInNode(highestRoot);
}
bool isEndOfEditableOrNonEditableContent(const VisiblePosition& p)
{
return p.isNotNull() && p.next().isNull();
}
VisiblePosition leftBoundaryOfLine(const VisiblePosition& c, TextDirection direction, bool* reachedBoundary)
{
return direction == TextDirection::LTR ? logicalStartOfLine(c, reachedBoundary) : logicalEndOfLine(c, reachedBoundary);
}
VisiblePosition rightBoundaryOfLine(const VisiblePosition& c, TextDirection direction, bool* reachedBoundary)
{
return direction == TextDirection::LTR ? logicalEndOfLine(c, reachedBoundary) : logicalStartOfLine(c, reachedBoundary);
}
static bool directionIsDownstream(SelectionDirection direction)
{
if (direction == SelectionDirection::Backward)
return false;
if (direction == SelectionDirection::Forward)
return true;
// FIXME: this code doesn't take into account the original direction of the element.
// I'm not fixing this now because I'm afraid there is some code in UIKit relying on
// this wrong behavior.
return direction == SelectionDirection::Right;
}
bool atBoundaryOfGranularity(const VisiblePosition& vp, TextGranularity granularity, SelectionDirection direction)
{
if (granularity == TextGranularity::CharacterGranularity)
return true;
VisiblePosition boundary;
bool useDownstream = directionIsDownstream(direction);
switch (granularity) {
case TextGranularity::WordGranularity:
// visible_units claims erroneously that the start and the end
// of a paragraph are the end and start of a word, respectively.
if ((useDownstream && isStartOfParagraph(vp)) || (!useDownstream && isEndOfParagraph(vp)))
return false;
// Note that "Left" and "Right" in this context apparently mean "upstream/previous" and "downstream/next".
boundary = useDownstream ? endOfWord(vp, LeftWordIfOnBoundary) : startOfWord(vp, RightWordIfOnBoundary);
break;
case TextGranularity::SentenceGranularity: {
auto boundaryInDirection = useDownstream ? endOfSentence : startOfSentence;
if (vp == boundaryInDirection(vp)) {
boundary = vp;
break;
}
auto position = useDownstream ? previousSentencePosition(vp) : nextSentencePosition(vp);
boundary = boundaryInDirection(position);
break;
}
case TextGranularity::LineGranularity:
boundary = vp;
boundary.setAffinity(useDownstream ? Affinity::Upstream : Affinity::Downstream);
boundary = useDownstream ? endOfLine(boundary) : startOfLine(boundary);
break;
case TextGranularity::ParagraphGranularity:
boundary = useDownstream ? endOfParagraph(vp) : startOfParagraph(vp);
break;
case TextGranularity::DocumentGranularity:
boundary = useDownstream ? endOfDocument(vp) : startOfDocument(vp);
break;
default:
ASSERT_NOT_REACHED();
break;
}
return vp == boundary;
}
bool withinTextUnitOfGranularity(const VisiblePosition& vp, TextGranularity granularity, SelectionDirection direction)
{
if (granularity == TextGranularity::CharacterGranularity || granularity == TextGranularity::DocumentGranularity)
return true;
bool useDownstream = directionIsDownstream(direction);
VisiblePosition prevBoundary;
VisiblePosition nextBoundary;
switch (granularity) {
case TextGranularity::WordGranularity:
// Note that "Left" and "Right" in this context apparently mean "upstream/previous" and "downstream/next".
prevBoundary = startOfWord(vp, (useDownstream ? RightWordIfOnBoundary : LeftWordIfOnBoundary));
nextBoundary = endOfWord(vp, (useDownstream ? RightWordIfOnBoundary : LeftWordIfOnBoundary));
// Workaround for <rdar://problem/7259611> Word boundary code on iPhone gives different results than desktop
if (endOfWord(prevBoundary, RightWordIfOnBoundary) != nextBoundary)
return false;
break;
case TextGranularity::SentenceGranularity:
prevBoundary = startOfSentence(vp);
nextBoundary = endOfSentence(vp);
break;
case TextGranularity::LineGranularity:
prevBoundary = startOfLine(vp);
nextBoundary = endOfLine(vp);
if (prevBoundary == nextBoundary) {
nextBoundary = nextLinePosition(nextBoundary, 0);
nextBoundary.setAffinity(Affinity::Upstream);
if (!inSameLine(prevBoundary, nextBoundary))
nextBoundary = vp.next();
}
break;
case TextGranularity::ParagraphGranularity:
prevBoundary = startOfParagraph(vp);
nextBoundary = endOfParagraph(vp);
break;
default:
ASSERT_NOT_REACHED();
break;
}
if (prevBoundary == nextBoundary)
return false;
if (vp == prevBoundary)
return useDownstream;
if (vp == nextBoundary)
return !useDownstream;
return (prevBoundary < vp && vp < nextBoundary);
}
static VisiblePosition nextCharacterBoundaryInDirection(const VisiblePosition& vp, SelectionDirection direction, EditingBoundaryCrossingRule rule)
{
return directionIsDownstream(direction) ? vp.next(rule) : vp.previous(rule);
}
static VisiblePosition nextWordBoundaryInDirection(const VisiblePosition& vp, SelectionDirection direction)
{
bool useDownstream = directionIsDownstream(direction);
bool withinUnitOfGranularity = withinTextUnitOfGranularity(vp, TextGranularity::WordGranularity, direction);
VisiblePosition result;
if (useDownstream) {
if (withinUnitOfGranularity)
result = endOfWord(vp, RightWordIfOnBoundary);
else {
VisiblePosition start = startOfWord(vp, RightWordIfOnBoundary);
if (start > vp && start != endOfWord(start))
result = start;
else {
// Do same thing as backwards traveling below.
start = vp;
while (true) {
result = startOfWord(nextWordPosition(start), RightWordIfOnBoundary);
if (result == start)
break;
// We failed to find a word boundary.
if (result.isNull() || result < start)
return VisiblePosition();
// We consider successs also the case where start is before element and result is after.
// This covers moving past images like words.
if (result != endOfWord(result)
|| (result.deepEquivalent().anchorNode() == start.deepEquivalent().anchorNode()
&& result.deepEquivalent().anchorType() == Position::PositionIsAfterAnchor
&& start.deepEquivalent().anchorType() == Position::PositionIsBeforeAnchor))
break;
start = result;
}
}
}
} else {
if (withinUnitOfGranularity)
result = startOfWord(vp, LeftWordIfOnBoundary);
else {
// This is complicated because:
// When given "Blah blah.|", endOfWord is "Blah blah|.", and previousWordPosition is "Blah| blah."
// When given "Blah blah. |", endOfWord is "Blah blah.| ", and previousWordPosition is "Blah |blah. ".
VisiblePosition end = endOfWord(vp, LeftWordIfOnBoundary);
if (end < vp && end != startOfWord(end))
result = end;
else {
end = vp;
while (true) {
result = endOfWord(previousWordPosition(end), RightWordIfOnBoundary);
if (result == end)
break;
if (result.isNull() || result > end)
return VisiblePosition();
if (result != startOfWord(result))
break;
end = result;
}
}
}
}
if (result == vp)
return VisiblePosition();
return result;
}
static VisiblePosition nextSentenceBoundaryInDirection(const VisiblePosition& vp, SelectionDirection direction)
{
bool useDownstream = directionIsDownstream(direction);
bool withinUnitOfGranularity = withinTextUnitOfGranularity(vp, TextGranularity::SentenceGranularity, direction);
VisiblePosition result;
if (withinUnitOfGranularity)
result = useDownstream ? endOfSentence(vp) : startOfSentence(vp);
else {
result = useDownstream ? nextSentencePosition(vp) : previousSentencePosition(vp);
if (result.isNull() || result == vp)
return VisiblePosition();
result = useDownstream ? startOfSentence(result) : endOfSentence(result);
}
if (result == vp)
return VisiblePosition();
// Positions can only be compared if they are in the same tree scope.
ASSERT_IMPLIES(areVisiblePositionsInSameTreeScope(result, vp), useDownstream ? (result > vp) : (result < vp));
return result;
}
static VisiblePosition nextLineBoundaryInDirection(const VisiblePosition& vp, SelectionDirection direction)
{
bool useDownstream = directionIsDownstream(direction);
VisiblePosition result = vp;
if (useDownstream) {
result.setAffinity(Affinity::Downstream);
result = isEndOfLine(result) ? startOfLine(nextLinePosition(result, result.lineDirectionPointForBlockDirectionNavigation())) : endOfLine(result);
} else {
result.setAffinity(Affinity::Upstream);
result = isStartOfLine(result) ? endOfLine(previousLinePosition(result, result.lineDirectionPointForBlockDirectionNavigation())) : startOfLine(result);
}
return result;
}
static VisiblePosition nextParagraphBoundaryInDirection(const VisiblePosition& position, SelectionDirection direction)
{
auto useDownstream = directionIsDownstream(direction);
auto lineDirection = position.lineDirectionPointForBlockDirectionNavigation();
if (atBoundaryOfGranularity(position, TextGranularity::ParagraphGranularity, direction))
return useDownstream ? startOfParagraph(nextParagraphPosition(position, lineDirection)) : endOfParagraph(previousParagraphPosition(position, lineDirection));
ASSERT(withinTextUnitOfGranularity(position, TextGranularity::ParagraphGranularity, direction));
return useDownstream ? endOfParagraph(position) : startOfParagraph(position);
}
static VisiblePosition nextDocumentBoundaryInDirection(const VisiblePosition& vp, SelectionDirection direction)
{
return directionIsDownstream(direction) ? endOfDocument(vp) : startOfDocument(vp);
}
VisiblePosition positionOfNextBoundaryOfGranularity(const VisiblePosition& vp, TextGranularity granularity, SelectionDirection direction)
{
switch (granularity) {
case TextGranularity::CharacterGranularity:
return nextCharacterBoundaryInDirection(vp, direction, CanCrossEditingBoundary);
case TextGranularity::WordGranularity:
return nextWordBoundaryInDirection(vp, direction);
case TextGranularity::SentenceGranularity:
return nextSentenceBoundaryInDirection(vp, direction);
case TextGranularity::LineGranularity:
return nextLineBoundaryInDirection(vp, direction);
case TextGranularity::ParagraphGranularity:
return nextParagraphBoundaryInDirection(vp, direction);
case TextGranularity::DocumentGranularity:
return nextDocumentBoundaryInDirection(vp, direction);
default:
ASSERT_NOT_REACHED();
return VisiblePosition();
}
}
std::optional<SimpleRange> enclosingTextUnitOfGranularity(const VisiblePosition& vp, TextGranularity granularity, SelectionDirection direction)
{
// This is particularly inefficient. We could easily obtain the answer with the boundaries computed below.
if (!withinTextUnitOfGranularity(vp, granularity, direction))
return std::nullopt;
VisiblePosition prevBoundary;
VisiblePosition nextBoundary;
bool useDownstream = directionIsDownstream(direction);
switch (granularity) {
case TextGranularity::CharacterGranularity:
prevBoundary = vp;
nextBoundary = prevBoundary.next();
break;
case TextGranularity::WordGranularity:
// NB: "Left" and "Right" in this context apparently mean "upstream/previous" and "downstream/next".
if (useDownstream) {
prevBoundary = startOfWord(vp, RightWordIfOnBoundary);
nextBoundary = endOfWord(vp, RightWordIfOnBoundary);
} else {
prevBoundary = startOfWord(vp, LeftWordIfOnBoundary);
nextBoundary = endOfWord(vp, LeftWordIfOnBoundary);
}
break;
case TextGranularity::SentenceGranularity:
prevBoundary = startOfSentence(vp);
nextBoundary = endOfSentence(vp);
break;
case TextGranularity::LineGranularity:
prevBoundary = startOfLine(vp);
nextBoundary = endOfLine(vp);
if (prevBoundary == nextBoundary) {
nextBoundary = nextLinePosition(nextBoundary, 0);
nextBoundary.setAffinity(Affinity::Upstream);
if (!inSameLine(prevBoundary, nextBoundary))
nextBoundary = vp.next();
}
break;
case TextGranularity::ParagraphGranularity:
prevBoundary = startOfParagraph(vp);
nextBoundary = endOfParagraph(vp);
break;
case TextGranularity::DocumentGranularity:
prevBoundary = startOfDocument(vp);
nextBoundary = endOfDocument(vp);
break;
default:
ASSERT_NOT_REACHED();
return std::nullopt;
}
if (prevBoundary.isNull() || nextBoundary.isNull())
return std::nullopt;
if (vp < prevBoundary || vp > nextBoundary)
return std::nullopt;
return makeSimpleRange(prevBoundary, nextBoundary);
}
std::ptrdiff_t distanceBetweenPositions(const VisiblePosition& a, const VisiblePosition& b)
{
if (a.isNull() || b.isNull())
return 0;
return a < b ? -characterCount(*makeSimpleRange(a, b)) : characterCount(*makeSimpleRange(b, a));
}
void charactersAroundPosition(const VisiblePosition& position, UChar32& oneAfter, UChar32& oneBefore, UChar32& twoBefore)
{
const int maxCharacters = 3;
UChar32 characters[maxCharacters] = { 0 };
if (position.isNull() || isStartOfDocument(position))
return;
VisiblePosition startPosition = position;
VisiblePosition endPosition = position;
VisiblePosition nextPosition = nextCharacterBoundaryInDirection(position, SelectionDirection::Forward, CannotCrossEditingBoundary);
if (nextPosition.isNotNull())
endPosition = nextPosition;
VisiblePosition previousPosition = nextCharacterBoundaryInDirection(position, SelectionDirection::Backward, CannotCrossEditingBoundary);
if (previousPosition.isNotNull()) {
startPosition = previousPosition;
previousPosition = nextCharacterBoundaryInDirection(previousPosition, SelectionDirection::Backward, CannotCrossEditingBoundary);
if (previousPosition.isNotNull())
startPosition = previousPosition;
}
if (startPosition != endPosition) {
String characterString = plainText(*makeSimpleRange(startPosition, endPosition)).replace(noBreakSpace, ' ');
for (int i = characterString.length() - 1, index = 0; i >= 0 && index < maxCharacters; --i) {
if (!index && nextPosition.isNull())
index++;
characters[index++] = characterString[i];
}
}
oneAfter = characters[0];
oneBefore = characters[1];
twoBefore = characters[2];
}
std::optional<SimpleRange> wordRangeFromPosition(const VisiblePosition& position)
{
if (position.isNull())
return std::nullopt;
if (auto range = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Backward))
return range;
if (auto range = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward))
return range;
VisiblePosition currentPosition = position;
do {
currentPosition = positionOfNextBoundaryOfGranularity(currentPosition, TextGranularity::WordGranularity, SelectionDirection::Backward);
} while (currentPosition.isNotNull() && !atBoundaryOfGranularity(currentPosition, TextGranularity::WordGranularity, SelectionDirection::Backward));
if (currentPosition.isNull())
currentPosition = positionOfNextBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward);
return makeSimpleRange(currentPosition, position);
}
VisiblePosition closestWordBoundaryForPosition(const VisiblePosition& position)
{
VisiblePosition result;
if (atBoundaryOfGranularity(position, TextGranularity::LineGranularity, SelectionDirection::Forward)) {
// Don't cross line boundaries.
result = position;
} else if (withinTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
// The position lies within a word.
if (auto wordRange = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
result = makeDeprecatedLegacyPosition(wordRange->start);
if (distanceBetweenPositions(position, result) > 1)
result = makeDeprecatedLegacyPosition(wordRange->end);
}
} else if (atBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Backward)) {
// The position is at the end of a word.
result = position;
} else {
// The position is not within a word.
// Go to the next boundary.
result = positionOfNextBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward);
// If there is no such boundary we go to the end of the element.
if (result.isNull())
result = endOfEditableContent(position);
}
return result;
}
std::optional<SimpleRange> rangeExpandedByCharactersInDirectionAtWordBoundary(const VisiblePosition& position, int numberOfCharactersToExpand, SelectionDirection direction)
{
Position start = position.deepEquivalent();
Position end = position.deepEquivalent();
for (int i = 0; i < numberOfCharactersToExpand; ++i) {
if (direction == SelectionDirection::Backward)
start = start.previous(Character);
else
end = end.next(Character);
}
if (direction == SelectionDirection::Backward && !atBoundaryOfGranularity(start, TextGranularity::WordGranularity, SelectionDirection::Backward))
start = startOfWord(start).deepEquivalent();
if (direction == SelectionDirection::Forward && !atBoundaryOfGranularity(end, TextGranularity::WordGranularity, SelectionDirection::Forward))
end = endOfWord(end).deepEquivalent();
return makeSimpleRange(start, end);
}
std::optional<SimpleRange> rangeExpandedAroundPositionByCharacters(const VisiblePosition& position, int numberOfCharactersToExpand)
{
Position start = position.deepEquivalent();
Position end = position.deepEquivalent();
for (int i = 0; i < numberOfCharactersToExpand; ++i) {
start = start.previous(Character);
end = end.next(Character);
}
return makeSimpleRange(start, end);
}
std::pair<VisiblePosition, WithinWordBoundary> wordBoundaryForPositionWithoutCrossingLine(const VisiblePosition& position)
{
if (atBoundaryOfGranularity(position, TextGranularity::LineGranularity, SelectionDirection::Forward))
return { position, WithinWordBoundary::No };
if (withinTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
auto adjustedPosition = position;
if (auto wordRange = enclosingTextUnitOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward)) {
adjustedPosition = makeDeprecatedLegacyPosition(wordRange->start);
if (distanceBetweenPositions(position, adjustedPosition) > 1)
adjustedPosition = makeDeprecatedLegacyPosition(wordRange->end);
}
return { adjustedPosition, WithinWordBoundary::Yes };
}
if (atBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Backward))
return { position, WithinWordBoundary::No };
auto nextWordBoundary = positionOfNextBoundaryOfGranularity(position, TextGranularity::WordGranularity, SelectionDirection::Forward);
return { nextWordBoundary.isNotNull() ? nextWordBoundary : endOfEditableContent(position), WithinWordBoundary::No };
}
}