Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 110 matching lines @@
 
 bool InlineTextBox::isSelected(int startPos, int endPos) const
 {
     int sPos = std::max(startPos - m_start, 0);
     // The position after a hard line break is considered to be past its end.
     // See the corresponding code in InlineTextBox::selectionState.
     int ePos = std::min(endPos - m_start, int(m_len) + (isLineBreak() ? 0 : 1));
     return (sPos < ePos);
 }
 
-RenderObject::SelectionState InlineTextBox::selectionState() const
+LayoutObject::SelectionState InlineTextBox::selectionState() const
 {
-    RenderObject::SelectionState state = renderer().selectionState();
-    if (state == RenderObject::SelectionStart || state == RenderObject::SelectionEnd || state == RenderObject::SelectionBoth) {
+    LayoutObject::SelectionState state = renderer().selectionState();
+    if (state == LayoutObject::SelectionStart || state == LayoutObject::SelectionEnd || state == LayoutObject::SelectionBoth) {
         int startPos, endPos;
         renderer().selectionStartEnd(startPos, endPos);
         // The position after a hard line break is considered to be past its end.
         // See the corresponding code in InlineTextBox::isSelected.
         int lastSelectable = start() + len() - (isLineBreak() ? 1 : 0);
 
         // FIXME: Remove -webkit-line-break: LineBreakAfterWhiteSpace.
         int endOfLineAdjustmentForCSSLineBreak = renderer().style()->lineBreak() == LineBreakAfterWhiteSpace ? -1 : 0;
-        bool start = (state != RenderObject::SelectionEnd && startPos >= m_start && startPos <= m_start + m_len + endOfLineAdjustmentForCSSLineBreak);
-        bool end = (state != RenderObject::SelectionStart && endPos > m_start && endPos <= lastSelectable);
+        bool start = (state != LayoutObject::SelectionEnd && startPos >= m_start && startPos <= m_start + m_len + endOfLineAdjustmentForCSSLineBreak);
+        bool end = (state != LayoutObject::SelectionStart && endPos > m_start && endPos <= lastSelectable);
         if (start && end)
-            state = RenderObject::SelectionBoth;
+            state = LayoutObject::SelectionBoth;
         else if (start)
-            state = RenderObject::SelectionStart;
+            state = LayoutObject::SelectionStart;
         else if (end)
-            state = RenderObject::SelectionEnd;
-        else if ((state == RenderObject::SelectionEnd || startPos < m_start) &&
-                 (state == RenderObject::SelectionStart || endPos > lastSelectable))
-            state = RenderObject::SelectionInside;
-        else if (state == RenderObject::SelectionBoth)
-            state = RenderObject::SelectionNone;
+            state = LayoutObject::SelectionEnd;
+        else if ((state == LayoutObject::SelectionEnd || startPos < m_start)
+            && (state == LayoutObject::SelectionStart || endPos > lastSelectable))
+            state = LayoutObject::SelectionInside;
+        else if (state == LayoutObject::SelectionBoth)
+            state = LayoutObject::SelectionNone;
     }
 
     // If there are ellipsis following, make sure their selection is updated.
     if (m_truncation != cNoTruncation && root().ellipsisBox()) {
         EllipsisBox* ellipsis = root().ellipsisBox();
-        if (state != RenderObject::SelectionNone) {
+        if (state != LayoutObject::SelectionNone) {
             int start, end;
             selectionStartEnd(start, end);
             // The ellipsis should be considered to be selected if the end of
             // the selection is past the beginning of the truncation and the
             // beginning of the selection is before or at the beginning of the
             // truncation.
             ellipsis->setSelectionState(end >= m_truncation && start <= m_truncation ?
-                RenderObject::SelectionInside : RenderObject::SelectionNone);
-        } else
-            ellipsis->setSelectionState(RenderObject::SelectionNone);
+                LayoutObject::SelectionInside : LayoutObject::SelectionNone);
+        } else {
+            ellipsis->setSelectionState(LayoutObject::SelectionNone);
+        }
     }
 
     return state;
 }
 
 LayoutRect InlineTextBox::localSelectionRect(int startPos, int endPos)
 {
     int sPos = std::max(startPos - m_start, 0);
     int ePos = std::min(endPos - m_start, (int)m_len);
 
@@ skipping 171 matching lines @@
 }
 
 void InlineTextBox::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
 {
     InlineTextBoxPainter(*this).paint(paintInfo, paintOffset);
 }
 
 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos) const
 {
     int startPos, endPos;
-    if (renderer().selectionState() == RenderObject::SelectionInside) {
+    if (renderer().selectionState() == LayoutObject::SelectionInside) {
         startPos = 0;
         endPos = renderer().textLength();
     } else {
         renderer().selectionStartEnd(startPos, endPos);
-        if (renderer().selectionState() == RenderObject::SelectionStart)
+        if (renderer().selectionState() == LayoutObject::SelectionStart)
             endPos = renderer().textLength();
-        else if (renderer().selectionState() == RenderObject::SelectionEnd)
+        else if (renderer().selectionState() == LayoutObject::SelectionEnd)
             startPos = 0;
     }
 
     sPos = std::max(startPos - m_start, 0);
     ePos = std::min(endPos - m_start, (int)m_len);
 }
 
 void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const FloatPointWillBeLayoutPoint& boxOrigin, DocumentMarker* marker, const RenderStyle& style, const Font& font, bool grammar)
 {
     InlineTextBoxPainter(*this).paintDocumentMarker(pt, boxOrigin.toFloatPoint(), marker, style, font, grammar);
@@ skipping 162 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.renderName(), &obj);
     const int rendererCharacterOffset = 75;
     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink