Make first-letter style to work with editing

Source/core/dom/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 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
@@ skipping 24 matching lines @@
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLTableElement.h"
 #include "core/platform/Logging.h"
 #include "core/rendering/InlineIterator.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderInline.h"
-#include "core/rendering/RenderText.h"
+#include "core/rendering/RenderTextFragment.h"
 #include "wtf/text/CString.h"
 #include "wtf/unicode/CharacterNames.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 static Node* nextRenderedEditable(Node* node)
 {
     while ((node = node->nextLeafNode())) {
@@ skipping 394 matching lines @@
     return !findParent(deprecatedNode()) && m_offset <= 0;
 }
 
 bool Position::atEndOfTree() const
 {
     if (isNull())
         return true;
     return !findParent(deprecatedNode()) && m_offset >= lastOffsetForEditing(deprecatedNode());
 }
 
+RenderObject* Position::renderer() const
+{
+    if (!m_anchorNode)
+        return 0;
+    RenderObject* renderer = m_anchorNode->renderer();

[eseidel, 2013/09/09 20:28:27]

Positions can be relative to anchor nodes other than being inside them, right?

[yosin_UTC9, 2013/09/20 09:30:26]

This function is replacement of Position.anchorNode()->renderer(), so I renamed
this function to rendererOfAnchorNode().

+    if (!renderer || !renderer->isText() || !toRenderText(renderer)->isTextFragment())
+        return renderer;
+    if (m_offset >= static_cast<int>(toRenderTextFragment(renderer)->textStartOffset()))
+        return renderer;
+    return toRenderTextFragment(renderer)->firstRenderTextInFirstLetter();
+}
+
+int Position::offsetInRenderer() const
+{
+    switch (m_isLegacyEditingPosition ? PositionIsOffsetInAnchor : m_anchorType) {
+    case PositionIsBeforeChildren:
+    case PositionIsBeforeAnchor:

[eseidel, 2013/09/09 20:28:27]

Wouldn't this possibly have a different renderer depending on what you're trying
to do with this position?

[yosin_UTC9, 2013/09/20 09:30:26]

This function does as same as deprecatedEditingOffset() except for :first-letter
support. Only FrameSelection::updateApperance() uses this. When we move Range
based FrameSelection, we can get rid of this function.

+    case PositionIsOffsetInAnchor: {
+        RenderObject* renderer = this->renderer();
+        if (!renderer || !renderer->isText())
+            return m_offset;
+        return m_offset - toRenderText(renderer)->textStartOffset();
+    }
+    case PositionIsAfterChildren:
+    case PositionIsAfterAnchor:
+        return offsetForPositionAfterAnchor();
+    }
+    ASSERT_NOT_REACHED();
+    return m_offset;
+}
+
 int Position::renderedOffset() const
 {
-    if (!deprecatedNode()->isTextNode())
+    RenderObject* renderer = this->renderer();
+    if (!renderer || !renderer->isText())
         return m_offset;
 
-    if (!deprecatedNode()->renderer())
-        return m_offset;
-
-    int result = 0;
-    RenderText* textRenderer = toRenderText(deprecatedNode()->renderer());
+    RenderText* textRenderer = toRenderText(renderer);
+    int result = textRenderer->textStartOffset();
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
         if (m_offset < start)
             return result;
         if (m_offset <= end) {
             result += m_offset - start;
             return result;
         }
         result += box->len();
@@ skipping 109 matching lines @@
     Node* startNode = deprecatedNode();
     if (!startNode)
         return Position();
 
     // iterate backward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
     PositionIterator currentPos = lastVisible;
     bool startEditable = startNode->rendererIsEditable();
+    RenderObject* startRenderer = renderer();
     Node* lastNode = startNode;
+    RenderObject* lastRenderer = startRenderer;
     bool boundaryCrossed = false;
     for (; !currentPos.atStart(); currentPos.decrement()) {
         Node* currentNode = currentPos.node();
+        RenderObject* currentRenderer = currentPos.renderer();
 
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing rendererIsEditable().
-        if (currentNode != lastNode) {
+        if (currentRenderer != lastRenderer) {
             // Don't change editability.
             bool currentEditable = currentNode->rendererIsEditable();
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
                     break;
                 boundaryCrossed = true;
             }
             lastNode = currentNode;
+            lastRenderer = currentPos.renderer();
         }
 
         // If we've moved to a position that is visually distinct, return the last saved position. There
         // is code below that terminates early if we're *about* to move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        RenderObject* renderer = currentNode->renderer();
-        if (!renderer || renderer->style()->visibility() != VISIBLE)
+        if (!currentRenderer || currentRenderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
             lastVisible = currentPos;
 
         // Don't move past a position that is visually distinct.  We could rely on code above to terminate and
         // return lastVisible on the next iteration, but we terminate early to avoid doing a nodeIndex() call.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentPos.atStartOfNode())
             return lastVisible;
 
         // Return position after tables and nodes which have content that can be ignored.
         if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
             if (currentPos.atEndOfNode())
                 return positionAfterNode(currentNode);
             continue;
         }
 
         // return current position if it is in rendered text
-        if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
-            if (currentNode != startNode) {
-                // This assertion fires in layout tests in the case-transform.html test because
-                // of a mix-up between offsets in the text in the DOM tree with text in the
-                // render tree which can have a different length due to case transformation.
-                // Until we resolve that, disable this so we can run the layout tests!
-                //ASSERT(currentOffset >= renderer->caretMaxOffset());
-                return createLegacyEditingPosition(currentNode, renderer->caretMaxOffset());
-            }
+        if (currentRenderer->isText() && toRenderText(currentRenderer)->firstTextBox()) {
+            RenderText* textRenderer = toRenderText(currentRenderer);
+            if (currentRenderer != startRenderer)
+                return createLegacyEditingPosition(currentNode, textRenderer->caretMaxOffset() + textRenderer->textStartOffset());
 
-            unsigned textOffset = currentPos.offsetInLeafNode();
-            RenderText* textRenderer = toRenderText(renderer);
+            unsigned textOffset = currentPos.offsetInLeafNode() - textRenderer->textStartOffset();
             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset <= box->start() + box->len()) {
                     if (textOffset > box->start())
                         return currentPos;
                     continue;
                 }
 
                 if (box == lastTextBox || textOffset != box->start() + box->len() + 1)
                     continue;
@@ skipping 41 matching lines @@
     Node* startNode = deprecatedNode();
     if (!startNode)
         return Position();
 
     // iterate forward from there, looking for a qualified position
     Node* boundary = enclosingVisualBoundary(startNode);
     // FIXME: PositionIterator should respect Before and After positions.
     PositionIterator lastVisible = m_anchorType == PositionIsAfterAnchor ? createLegacyEditingPosition(m_anchorNode.get(), caretMaxOffset(m_anchorNode.get())) : *this;
     PositionIterator currentPos = lastVisible;
     bool startEditable = startNode->rendererIsEditable();
+    RenderObject* startRenderer = renderer();
     Node* lastNode = startNode;
+    RenderObject* lastRenderer = startRenderer;
     bool boundaryCrossed = false;
     for (; !currentPos.atEnd(); currentPos.increment()) {
         Node* currentNode = currentPos.node();
+        RenderObject* currentRenderer = currentPos.renderer();
 
         // Don't check for an editability change if we haven't moved to a different node,
         // to avoid the expense of computing rendererIsEditable().
-        if (currentNode != lastNode) {
+        if (currentRenderer!= lastRenderer) {
             // Don't change editability.
             bool currentEditable = currentNode->rendererIsEditable();
             if (startEditable != currentEditable) {
                 if (rule == CannotCrossEditingBoundary)
                     break;
                 boundaryCrossed = true;
             }
 
             lastNode = currentNode;
+            lastRenderer = currentRenderer;
         }
 
         // stop before going above the body, up into the head
         // return the last visible streamer position
         if (currentNode->hasTagName(bodyTag) && currentPos.atEndOfNode())
             break;
 
         // Do not move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
         // Do not move past a visually disinct position.
         // Note: The first position after the last in a node whose ends are visually distinct
         // positions will be [boundary->parentNode(), originalBlock->nodeIndex() + 1].
         if (boundary && boundary->parentNode() == currentNode)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        RenderObject* renderer = currentNode->renderer();
-        if (!renderer || renderer->style()->visibility() != VISIBLE)
+        if (!currentRenderer || currentRenderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
             lastVisible = currentPos;
 
         // Return position before tables and nodes which have content that can be ignored.
         if (editingIgnoresContent(currentNode) || isTableElement(currentNode)) {
-            if (currentPos.offsetInLeafNode() <= renderer->caretMinOffset())
-                return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
+            if (currentPos.offsetInLeafNode() <= currentRenderer->caretMinOffset())
+                return createLegacyEditingPosition(currentNode, currentRenderer->caretMinOffset());
             continue;
         }
 
         // return current position if it is in rendered text
-        if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
-            if (currentNode != startNode) {
-                ASSERT(currentPos.atStartOfNode());
-                return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
-            }
+        if (currentRenderer->isText() && toRenderText(currentRenderer)->firstTextBox()) {
+            RenderText* textRenderer = toRenderText(currentRenderer);
+            if (currentRenderer != startRenderer)
+                return createLegacyEditingPosition(currentNode, textRenderer->caretMinOffset() + textRenderer->textStartOffset());
 
-            unsigned textOffset = currentPos.offsetInLeafNode();
-            RenderText* textRenderer = toRenderText(renderer);
+            unsigned textOffset = currentPos.offsetInLeafNode() - textRenderer->textStartOffset();
             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset <= box->end()) {
                     if (textOffset >= box->start())
                         return currentPos;
                     continue;
                 }
 
                 if (box == lastTextBox || textOffset != box->start() + box->len())
                     continue;
@@ skipping 40 matching lines @@
     for (RenderObject *o = renderer->firstChild(); o && o != stop; o = o->nextInPreOrder())
         if (o->nonPseudoNode()) {
             if ((o->isText() && boundingBoxLogicalHeight(o, toRenderText(o)->linesBoundingBox()))
                 || (o->isBox() && toRenderBox(o)->pixelSnappedLogicalHeight())
                 || (o->isRenderInline() && isEmptyInline(o) && boundingBoxLogicalHeight(o, toRenderInline(o)->linesBoundingBox())))
                 return true;
         }
     return false;
 }
 
+// FIXME: Caller of nodeIsUserSelectNode() should consider first letter and
+// remaining text have different user-select CSS property.
 bool Position::nodeIsUserSelectNone(Node* node)
 {
-    return node && node->renderer() && node->renderer()->style()->userSelect() == SELECT_NONE && node->renderer()->style()->userModify() == READ_ONLY;
+    return node && rendererIsUserSelectNone(node->renderer());
+}
+
+bool Position::rendererIsUserSelectNone(RenderObject* renderer)
+{
+    return renderer && renderer->style()->userSelect() == SELECT_NONE && renderer->style()->userModify() == READ_ONLY;
 }
 
 ContainerNode* Position::findParent(const Node* node)
 {
     return node->parentNode();
 }
 
 #if ENABLE(USERSELECT_ALL)
 bool Position::nodeIsUserSelectAll(const Node* node)
 {
@@ skipping 18 matching lines @@
             break;
         candidateRoot = parent;
         parent = candidateRoot->parentNode();
     }
     return candidateRoot;
 }
 #endif
 
 bool Position::isCandidate() const
 {
-    if (isNull())
-        return false;
-
-    RenderObject* renderer = deprecatedNode()->renderer();
+    RenderObject* renderer = this->renderer();
     if (!renderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE)
         return false;
 
     if (renderer->isBR())
         // FIXME: The condition should be m_anchorType == PositionIsBeforeAnchor, but for now we still need to support legacy positions.
         return !m_offset && m_anchorType != PositionIsAfterAnchor && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (renderer->isText())
-        return !nodeIsUserSelectNone(deprecatedNode()) && inRenderedText();
+        return !rendererIsUserSelectNone(renderer) && inRenderedText();
 
     if (isTableElement(deprecatedNode()) || editingIgnoresContent(deprecatedNode()))
         return (atFirstEditingPositionForNode() || atLastEditingPositionForNode()) && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
     if (isHTMLHtmlElement(m_anchorNode.get()))
         return false;
 
     if (renderer->isBlockFlow()) {
         if (toRenderBlock(renderer)->logicalHeight() || m_anchorNode->hasTagName(bodyTag)) {
             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(renderer))
                 return atFirstEditingPositionForNode() && !Position::nodeIsUserSelectNone(deprecatedNode());
             return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
         }
     } else
         return m_anchorNode->rendererIsEditable() && !Position::nodeIsUserSelectNone(deprecatedNode()) && atEditingBoundary();
 
     return false;
 }
 
 bool Position::inRenderedText() const
 {
-    if (isNull() || !deprecatedNode()->isTextNode())
+    RenderObject* renderer = this->renderer();
+    if (!renderer || !renderer->isText())
         return false;
 
-    RenderObject* renderer = deprecatedNode()->renderer();
-    if (!renderer)
-        return false;
-
-    RenderText *textRenderer = toRenderText(renderer);
+    RenderText* textRenderer = toRenderText(renderer);
+    int offset = m_offset - textRenderer->textStartOffset();
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
-        if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
+        if (offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
-        if (box->containsCaretOffset(m_offset))
+        if (box->containsCaretOffset(offset)) {
             // Return false for offsets inside composed characters.
-            return m_offset == 0 || m_offset == textRenderer->nextOffset(textRenderer->previousOffset(m_offset));
+            return !offset || offset == textRenderer->nextOffset(textRenderer->previousOffset(offset));
+        }
     }
 
     return false;
 }
 
 bool Position::isRenderedCharacter() const
 {
-    if (isNull() || !deprecatedNode()->isTextNode())
-        return false;
-
-    RenderObject* renderer = deprecatedNode()->renderer();
-    if (!renderer)
+    RenderObject* renderer = this->renderer();
+    if (!renderer || !renderer->isText())
         return false;
 
     RenderText* textRenderer = toRenderText(renderer);
+    int offset = m_offset - textRenderer->textStartOffset();
     for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
-        if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
+        if (offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
-        if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
+        if (offset >= static_cast<int>(box->start()) && offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
 
     return false;
 }
 
 bool Position::rendersInDifferentPosition(const Position &pos) const
 {
-    if (isNull() || pos.isNull())
-        return false;
-
-    RenderObject* renderer = deprecatedNode()->renderer();
+    RenderObject* renderer = this->renderer();
     if (!renderer)
         return false;
 
-    RenderObject* posRenderer = pos.deprecatedNode()->renderer();
+    RenderObject* posRenderer = pos.renderer();
     if (!posRenderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE ||
         posRenderer->style()->visibility() != VISIBLE)
         return false;
 
     if (deprecatedNode() == pos.deprecatedNode()) {
         if (deprecatedNode()->hasTagName(brTag))
             return false;
@@ skipping 160 matching lines @@
     while (position != lastPosition) {
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = deprecatedEditingOffset();
-    RenderObject* renderer = deprecatedNode()->renderer();
+    RenderObject* renderer = this->renderer();
 
     if (!renderer->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
             // of RenderObject::createVisiblePosition().
             Position equivalent = downstreamIgnoringEditingBoundaries(*this);
             if (equivalent == *this) {
                 equivalent = upstreamIgnoringEditingBoundaries(*this);
                 if (equivalent == *this || downstreamIgnoringEditingBoundaries(equivalent) == *this)
                     return;
             }
 
             equivalent.getInlineBoxAndOffset(UPSTREAM, primaryDirection, inlineBox, caretOffset);
             return;
         }
         if (renderer->isBox()) {
             inlineBox = toRenderBox(renderer)->inlineBoxWrapper();
             if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() && caretOffset < inlineBox->caretMaxOffset()))
                 return;
         }
     } else {
         RenderText* textRenderer = toRenderText(renderer);
 
         InlineTextBox* box;
         InlineTextBox* candidate = 0;
 
+        if (textRenderer->isTextFragment() && toRenderTextFragment(textRenderer)->firstLetter()) {
+            if (caretOffset) {
+                caretOffset -= textRenderer->textStartOffset();
+            } else {
+                textRenderer = toRenderTextFragment(textRenderer)->firstRenderTextInFirstLetter();
+                if (!textRenderer)
+                    return;
+            }
+        }
+
         for (box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (caretOffset < caretMinOffset || caretOffset > caretMaxOffset || (caretOffset == caretMaxOffset && box->isLineBreak()))
                 continue;
 
             if (caretOffset > caretMinOffset && caretOffset < caretMaxOffset) {
                 inlineBox = box;
                 return;
@@ skipping 193 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const WebCore::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif