Reformat comments in core/layout/line

third_party/WebKit/Source/core/layout/line/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.
+ * 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 155 matching lines @@
     else if (state == SelectionBoth)
       state = SelectionNone;
   }
 
   // If there are ellipsis following, make sure their selection is updated.
   if (m_truncation != cNoTruncation && root().ellipsisBox()) {
     EllipsisBox* ellipsis = root().ellipsisBox();
     if (state != 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.
+      // 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
                                       ? SelectionInside
                                       : SelectionNone);
     } else {
       ellipsis->setSelectionState(SelectionNone);
     }
   }
 
   return state;
 }
 
 bool InlineTextBox::hasWrappedSelectionNewline() const {
-  // TODO(wkorman): We shouldn't need layout at this point and it should
-  // be enforced by DocumentLifecycle. http://crbug.com/537821
-  // Bail out as currently looking up selection state can cause the editing
-  // code can force a re-layout while scrutinizing the editing position, and
+  // TODO(wkorman): We shouldn't need layout at this point and it should be
+  // enforced by DocumentLifecycle. http://crbug.com/537821
+  // Bail out as currently looking up selection state can cause the editing code
+  // can force a re-layout while scrutinizing the editing position, and
   // InlineTextBox instances are not guaranteed to survive a re-layout.
   if (getLineLayoutItem().needsLayout())
     return false;
 
   SelectionState state = getSelectionState();
   return (state == SelectionStart || state == SelectionInside)
-         // Checking last leaf child can be slow, so we make sure to do this only
-         // after the other simple conditionals.
+         // Checking last leaf child can be slow, so we make sure to do this
+         // only after the other simple conditionals.
          && (root().lastLeafChild() == this)
          // It's possible to have mixed LTR/RTL on a single line, and we only
          // want to paint a newline when we're the last leaf child and we make
          // sure there isn't a differently-directioned box following us.
          && ((!isLeftToRightDirection() && root().firstSelectedBox() == this) ||
              (isLeftToRightDirection() && root().lastSelectedBox() == this));
 }
 
 float InlineTextBox::newlineSpaceWidth() const {
   const ComputedStyle& styleToUse =
@@ skipping 19 matching lines @@
   StringBuilder charactersWithHyphen;
   bool respectHyphen = ePos == m_len && hasHyphen();
   TextRun textRun =
       constructTextRun(styleToUse, respectHyphen ? &charactersWithHyphen : 0);
 
   LayoutPoint startingPoint = LayoutPoint(logicalLeft(), selTop);
   LayoutRect r;
   if (sPos || ePos != static_cast<int>(m_len)) {
     r = LayoutRect(enclosingIntRect(font.selectionRectForText(
         textRun, FloatPoint(startingPoint), selHeight.toInt(), sPos, ePos)));
-  } else {  // Avoid computing the font width when the entire line box is selected as an optimization.
+  } else {
+    // Avoid computing the font width when the entire line box is selected as an
+    // optimization.
     r = LayoutRect(enclosingIntRect(
         LayoutRect(startingPoint, LayoutSize(m_logicalWidth, selHeight))));
   }
 
   LayoutUnit logicalWidth = r.width();
   if (r.x() > logicalRight())
     logicalWidth = LayoutUnit();
   else if (r.maxX() > logicalRight())
     logicalWidth = logicalRight() - r.x();
 
@@ skipping 57 matching lines @@
                                            LayoutUnit visibleLeftEdge,
                                            LayoutUnit visibleRightEdge,
                                            LayoutUnit ellipsisWidth,
                                            LayoutUnit& truncatedWidth,
                                            bool& foundBox) {
   if (foundBox) {
     setTruncation(cFullTruncation);
     return LayoutUnit(-1);
   }
 
-  // For LTR this is the left edge of the box, for RTL, the right edge in parent coordinates.
+  // For LTR this is the left edge of the box, for RTL, the right edge in parent
+  // coordinates.
   LayoutUnit ellipsisX = flowIsLTR ? visibleRightEdge - ellipsisWidth
                                    : visibleLeftEdge + ellipsisWidth;
 
   // Criteria for full truncation:
   // LTR: the left edge of the ellipsis is to the left of our text run.
   // RTL: the right edge of the ellipsis is to the right of our text run.
   bool ltrFullTruncation = flowIsLTR && ellipsisX <= logicalLeft();
   bool rtlFullTruncation =
       !flowIsLTR && ellipsisX >= logicalLeft() + logicalWidth();
   if (ltrFullTruncation || rtlFullTruncation) {
-    // Too far.  Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box.
+    // Too far.  Just set full truncation, but return -1 and let the ellipsis
+    // just be placed at the edge of the box.
     setTruncation(cFullTruncation);
     foundBox = true;
     return LayoutUnit(-1);
   }
 
   bool ltrEllipsisWithinBox = flowIsLTR && (ellipsisX < logicalRight());
   bool rtlEllipsisWithinBox = !flowIsLTR && (ellipsisX > logicalLeft());
   if (ltrEllipsisWithinBox || rtlEllipsisWithinBox) {
     foundBox = true;
 
-    // The inline box may have different directionality than it's parent.  Since truncation
-    // behavior depends both on both the parent and the inline block's directionality, we
-    // must keep track of these separately.
+    // The inline box may have different directionality than it's parent. Since
+    // truncation behavior depends both on both the parent and the inline
+    // block's directionality, we must keep track of these separately.
     bool ltr = isLeftToRightDirection();
     if (ltr != flowIsLTR) {
-      // Width in pixels of the visible portion of the box, excluding the ellipsis.
+      // Width in pixels of the visible portion of the box, excluding the
+      // ellipsis.
       int visibleBoxWidth =
           (visibleRightEdge - visibleLeftEdge - ellipsisWidth).toInt();
       ellipsisX = flowIsLTR ? logicalLeft() + visibleBoxWidth
                             : logicalRight() - visibleBoxWidth;
     }
 
     int offset = offsetForPosition(ellipsisX, false);
     if (offset == 0 && ltr == flowIsLTR) {
-      // No characters should be laid out.  Set ourselves to full truncation and place the ellipsis at the min of our start
-      // and the ellipsis edge.
+      // No characters should be laid out.  Set ourselves to full truncation and
+      // place the ellipsis at the min of our start and the ellipsis edge.
       setTruncation(cFullTruncation);
       truncatedWidth += ellipsisWidth;
       return std::min(ellipsisX, logicalLeft());
     }
 
     // Set the truncation index on the text run.
     setTruncation(offset);
 
-    // If we got here that means that we were only partially truncated and we need to return the pixel offset at which
-    // to place the ellipsis. Where the text and its flow have opposite directions then our offset into the text is at
-    // the start of the part that will be visible.
+    // If we got here that means that we were only partially truncated and we
+    // need to return the pixel offset at which to place the ellipsis. Where the
+    // text and its flow have opposite directions then our offset into the text
+    // is at the start of the part that will be visible.
     LayoutUnit widthOfVisibleText(getLineLayoutItem().width(
         ltr == flowIsLTR ? m_start : offset,
         ltr == flowIsLTR ? offset : m_len - offset, textPos(),
         flowIsLTR ? LTR : RTL, isFirstLineStyle()));
 
     // The ellipsis needs to be placed just after the last visible character.
     // Where "after" is defined by the flow directionality, not the inline
     // box directionality.
-    // e.g. In the case of an LTR inline box truncated in an RTL flow then we can
-    // have a situation such as |Hello| -> |...He|
+    // e.g. In the case of an LTR inline box truncated in an RTL flow then we
+    // can have a situation such as |Hello| -> |...He|
     truncatedWidth += widthOfVisibleText + ellipsisWidth;
     if (flowIsLTR)
       return logicalLeft() + widthOfVisibleText;
     return logicalRight() - widthOfVisibleText - ellipsisWidth;
   }
   truncatedWidth += logicalWidth();
   return LayoutUnit(-1);
 }
 
 bool InlineTextBox::isLineBreak() const {
@@ skipping 22 matching lines @@
                                             locationInContainer,
                                             rect) == StopHitTesting)
       return true;
   }
   return false;
 }
 
 bool InlineTextBox::getEmphasisMarkPosition(
     const ComputedStyle& style,
     TextEmphasisPosition& emphasisPosition) const {
-  // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
+  // This function returns true if there are text emphasis marks and they are
+  // suppressed by ruby text.
   if (style.getTextEmphasisMark() == TextEmphasisMarkNone)
     return false;
 
   emphasisPosition = style.getTextEmphasisPosition();
+  // Ruby text is always over, so it cannot suppress emphasis marks under.
   if (emphasisPosition == TextEmphasisPositionUnder)
-    return true;  // Ruby text is always over, so it cannot suppress emphasis marks under.
+    return true;
 
   LineLayoutBox containingBlock = getLineLayoutItem().containingBlock();
+  // This text is not inside a ruby base, so it does not have ruby text over it.
   if (!containingBlock.isRubyBase())
-    return true;  // This text is not inside a ruby base, so it does not have ruby text over it.
+    return true;
 
+  // Cannot get the ruby text.
   if (!containingBlock.parent().isRubyRun())
-    return true;  // Cannot get the ruby text.
+    return true;
 
   LineLayoutRubyText rubyText =
       LineLayoutRubyRun(containingBlock.parent()).rubyText();
 
-  // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
+  // The emphasis marks over are suppressed only if there is a ruby text box and
+  // it not empty.
   return !rubyText || !rubyText.firstLineBox();
 }
 
 void InlineTextBox::paint(const PaintInfo& paintInfo,
                           const LayoutPoint& paintOffset,
                           LayoutUnit /*lineTop*/,
                           LayoutUnit /*lineBottom*/) const {
   InlineTextBoxPainter(*this).paint(paintInfo, paintOffset);
 }
 
@@ skipping 44 matching lines @@
 
 int InlineTextBox::caretMinOffset() const {
   return m_start;
 }
 
 int InlineTextBox::caretMaxOffset() const {
   return m_start + m_len;
 }
 
 LayoutUnit InlineTextBox::textPos() const {
-  // When computing the width of a text run, LayoutBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
-  // from the containing block edge in its measurement. textPos() should be consistent so the text are laid out in the same width.
+  // When computing the width of a text run, LayoutBlock::
+  // computeInlineDirectionPositionsForLine() doesn't include the actual offset
+  // from the containing block edge in its measurement. textPos() should be
+  // consistent so the text are laid out in the same width.
   if (logicalLeft() == 0)
     return LayoutUnit();
   return logicalLeft() - root().logicalLeft();
 }
 
 int InlineTextBox::offsetForPosition(LayoutUnit lineOffset,
                                      bool includePartialGlyphs) const {
   if (isLineBreak())
     return 0;
 
@@ skipping 41 matching lines @@
     return true;
 
   // Offsets outside the box are always "out".
   if (offset > pastEnd)
     return false;
 
   // Offsets at the end are "out" for line breaks (they are on the next line).
   if (isLineBreak())
     return false;
 
-  // Offsets at the end are "in" for normal boxes (but the caller has to check affinity).
+  // Offsets at the end are "in" for normal boxes (but the caller has to check
+  // affinity).
   return true;
 }
 
 void InlineTextBox::characterWidths(Vector<float>& widths) const {
   if (!m_len)
     return;
 
   FontCachePurgePreventer fontCachePurgePreventer;
   ASSERT(getLineLayoutItem().text());
 
@@ skipping 38 matching lines @@
     maximumLength = string.length();
   }
 
   ASSERT(maximumLength >= static_cast<int>(string.length()));
 
   TextRun run(string, textPos().toFloat(), expansion(), expansionBehavior(),
               direction(), dirOverride() || style.rtlOrdering() == VisualOrder);
   run.setTabSize(!style.collapseWhiteSpace(), style.getTabSize());
   run.setTextJustify(style.getTextJustify());
 
-  // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
+  // Propagate the maximum length of the characters buffer to the TextRun, even
+  // when we're only processing a substring.
   run.setCharactersLength(maximumLength);
   ASSERT(run.charactersLength() >= run.length());
   return run;
 }
 
 TextRun InlineTextBox::constructTextRunForInspector(
     const ComputedStyle& style) const {
   return InlineTextBox::constructTextRun(style);
 }
 
@@ skipping 24 matching lines @@
   const int layoutObjectCharacterOffset = 75;
   for (; printedCharacters < layoutObjectCharacterOffset; printedCharacters++)
     fputc(' ', stderr);
   fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(),
           value.utf8().data());
 }
 
 #endif
 
 }  // namespace blink