third_party/WebKit/Source/core/editing/PlainTextRange.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
   3  * Copyright (C) 2005 Alexey Proskuryakov.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "core/editing/PlainTextRange.h"
  29
  30 #include "core/dom/ContainerNode.h"
  31 #include "core/dom/Document.h"
  32 #include "core/dom/Range.h"
  33 #include "core/editing/EphemeralRange.h"
  34 #include "core/editing/VisiblePosition.h"
  35 #include "core/editing/iterators/TextIterator.h"
  36
  37 namespace blink {
  38
  39 PlainTextRange::PlainTextRange()
  40     : m_start(kNotFound)
  41     , m_end(kNotFound)
  42 {
  43 }
  44
  45 PlainTextRange::PlainTextRange(int location)
  46     : m_start(location)
  47     , m_end(location)
  48 {
  49     ASSERT(location >= 0);
  50 }
  51
  52 PlainTextRange::PlainTextRange(int start, int end)
  53     : m_start(start)
  54     , m_end(end)
  55 {
  56     ASSERT(start >= 0);
  57     ASSERT(end >= 0);
  58     ASSERT(start <= end);
  59 }
  60
  61 EphemeralRange PlainTextRange::createRange(const ContainerNode& scope) const
  62 {
  63     return createRangeFor(scope, ForGeneric);
  64 }
  65
  66 EphemeralRange PlainTextRange::createRangeForSelection(const ContainerNode& scope) const
  67 {
  68     return createRangeFor(scope, ForSelection);
  69 }
  70
  71 EphemeralRange PlainTextRange::createRangeFor(const ContainerNode& scope, GetRangeFor getRangeFor) const
  72 {
  73     ASSERT(isNotNull());
  74
  75     size_t docTextPosition = 0;
  76     bool startRangeFound = false;
  77
  78     Position textRunStartPosition;
  79     Position textRunEndPosition;
  80
  81     TextIteratorBehaviorFlags behaviorFlags = TextIteratorEmitsObjectReplacementCharacter;
  82     if (getRangeFor == ForSelection)
  83         behaviorFlags |= TextIteratorEmitsCharactersBetweenAllVisiblePositions;
  84     auto range = EphemeralRange::rangeOfContents(scope);
  85     TextIterator it(range.startPosition(), range.endPosition(), behaviorFlags);
  86
  87     // FIXME: the atEnd() check shouldn't be necessary, workaround for
  88     // <http://bugs.webkit.org/show_bug.cgi?id=6289>.
  89     if (!start() && !length() && it.atEnd())
  90         return EphemeralRange(Position(it.currentContainer(), 0));
  91
  92     Position resultStart = Position(&scope.document(), 0);
  93     Position resultEnd = resultStart;
  94
  95     for (; !it.atEnd(); it.advance()) {
  96         int len = it.length();
  97
  98         textRunStartPosition = it.startPositionInCurrentContainer();
  99         textRunEndPosition = it.endPositionInCurrentContainer();
 100
 101         bool foundStart = start() >= docTextPosition && start() <= docTextPosition + len;
 102         bool foundEnd = end() >= docTextPosition && end() <= docTextPosition + len;
 103
 104         // Fix textRunRange->endPosition(), but only if foundStart || foundEnd, because it is only
 105         // in those cases that textRunRange is used.
 106         if (foundEnd) {
 107             // FIXME: This is a workaround for the fact that the end of a run
 108             // is often at the wrong position for emitted '\n's or if the
 109             // layoutObject of the current node is a replaced element.
 110             if (len == 1 && (it.text().characterAt(0) == '\n' || it.isInsideReplacedElement())) {
 111                 it.advance();
 112                 if (!it.atEnd()) {
 113                     textRunEndPosition = it.startPositionInCurrentContainer();
 114                 } else {
 115                     Position runEnd = VisiblePosition(textRunStartPosition).next().deepEquivalent();
 116                     if (runEnd.isNotNull())
 117                         textRunEndPosition = runEnd;
 118                 }
 119             }
 120         }
 121
 122         if (foundStart) {
 123             startRangeFound = true;
 124             if (textRunStartPosition.containerNode()->isTextNode()) {
 125                 int offset = start() - docTextPosition;
 126                 resultStart = Position(textRunStartPosition.containerNode(), offset + textRunStartPosition.offsetInContainerNode());
 127             } else {
 128                 if (start() == docTextPosition)
 129                     resultStart = textRunStartPosition;
 130                 else
 131                     resultStart = textRunEndPosition;
 132             }
 133         }
 134
 135         if (foundEnd) {
 136             if (textRunStartPosition.containerNode()->isTextNode()) {
 137                 int offset = end() - docTextPosition;
 138                 resultEnd = Position(textRunStartPosition.containerNode(), offset + textRunStartPosition.offsetInContainerNode());
 139             } else {
 140                 if (end() == docTextPosition)
 141                     resultEnd = textRunStartPosition;
 142                 else
 143                     resultEnd = textRunEndPosition;
 144             }
 145             docTextPosition += len;
 146             break;
 147         }
 148         docTextPosition += len;
 149     }
 150
 151     if (!startRangeFound)
 152         return EphemeralRange();
 153
 154     if (length() && end() > docTextPosition) { // end() is out of bounds
 155         resultEnd = textRunEndPosition;
 156     }
 157
 158     return EphemeralRange(resultStart.toOffsetInAnchor(), resultEnd.toOffsetInAnchor());
 159 }
 160
 161 PlainTextRange PlainTextRange::create(const ContainerNode& scope, const EphemeralRange& range)
 162 {
 163     if (range.isNull())
 164         return PlainTextRange();
 165
 166     // The critical assumption is that this only gets called with ranges that
 167     // concentrate on a given area containing the selection root. This is done
 168     // because of text fields and textareas. The DOM for those is not
 169     // directly in the document DOM, so ensure that the range does not cross a
 170     // boundary of one of those.
 171     Node* startContainer = range.startPosition().containerNode();
 172     if (startContainer != &scope && !startContainer->isDescendantOf(&scope))
 173         return PlainTextRange();
 174     Node* endContainer = range.endPosition().containerNode();
 175     if (endContainer != scope && !endContainer->isDescendantOf(&scope))
 176         return PlainTextRange();
 177
 178     size_t start = TextIterator::rangeLength(Position(&const_cast<ContainerNode&>(scope), 0), range.startPosition());
 179     size_t end = TextIterator::rangeLength(Position(&const_cast<ContainerNode&>(scope), 0), range.endPosition());
 180
 181     return PlainTextRange(start, end);
 182 }
 183
 184 PlainTextRange PlainTextRange::create(const ContainerNode& scope, const Range& range)
 185 {
 186     return create(scope, EphemeralRange(&range));
 187 }
 188
 189 }