Place ellipsis correctly inside inline-blocks

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.
  *
  * 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 299 matching lines @@
 
 void InlineTextBox::clearTruncation() {
   setTruncation(cNoTruncation);
 }
 
 LayoutUnit InlineTextBox::placeEllipsisBox(bool flowIsLTR,
                                            LayoutUnit visibleLeftEdge,
                                            LayoutUnit visibleRightEdge,
                                            LayoutUnit ellipsisWidth,
                                            LayoutUnit& truncatedWidth,
-                                           bool& foundBox) {
+                                           bool& foundBox,
+                                           LayoutUnit logicalLeftOffset) {
   if (foundBox) {
     setTruncation(cFullTruncation);
     return LayoutUnit(-1);
   }
 
+  // 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.
+  LayoutUnit adjustedLogicalLeft = logicalLeftOffset + logicalLeft();
+
   // 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();
+  if (isLeftToRightDirection() == flowIsLTR && !flowIsLTR &&
+      logicalLeftOffset < 0)
+    ellipsisX -= logicalLeftOffset;
+
+  bool ltrFullTruncation = flowIsLTR && ellipsisX <= adjustedLogicalLeft;
   bool rtlFullTruncation =
-      !flowIsLTR && ellipsisX >= logicalLeft() + logicalWidth();
+      !flowIsLTR && ellipsisX > adjustedLogicalLeft + 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.
     setTruncation(cFullTruncation);
     foundBox = true;
     return LayoutUnit(-1);
   }
 
-  bool ltrEllipsisWithinBox = flowIsLTR && (ellipsisX < logicalRight());
-  bool rtlEllipsisWithinBox = !flowIsLTR && (ellipsisX > logicalLeft());
+  bool ltrEllipsisWithinBox =
+      flowIsLTR && ellipsisX < adjustedLogicalLeft + logicalWidth();
+  bool rtlEllipsisWithinBox = !flowIsLTR && ellipsisX > adjustedLogicalLeft;
   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.
     bool ltr = isLeftToRightDirection();
     if (ltr != flowIsLTR) {
       // Width in pixels of the visible portion of the box, excluding the
       // ellipsis.
       LayoutUnit visibleBoxWidth =
           visibleRightEdge - visibleLeftEdge - ellipsisWidth;
-      ellipsisX = flowIsLTR ? logicalLeft() + visibleBoxWidth
+      ellipsisX = flowIsLTR ? adjustedLogicalLeft + visibleBoxWidth
                             : logicalRight() - visibleBoxWidth;
     }
 
     // The box's width includes partial glyphs, so respect that when placing
     // the ellipsis.
     int offset = offsetForPosition(ellipsisX);
-    if (offset == 0 && ltr == flowIsLTR) {
+    // Full truncation is only necessary when we're flowing left-to-right.
+    if (flowIsLTR && 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.
       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.
     LayoutUnit widthOfVisibleText(getLineLayoutItem().width(
         ltr == flowIsLTR ? m_start : m_start + offset,
         ltr == flowIsLTR ? offset : m_len - offset, textPos(),
         flowIsLTR ? TextDirection::kLtr : TextDirection::kRtl,
         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|
     truncatedWidth += widthOfVisibleText + ellipsisWidth;
     if (flowIsLTR)
       return logicalLeft() + widthOfVisibleText;
-    return logicalRight() - widthOfVisibleText - ellipsisWidth;
+    LayoutUnit result = logicalRight() - widthOfVisibleText - ellipsisWidth;
+    return result;
   }
   truncatedWidth += logicalWidth();
   return LayoutUnit(-1);
 }
 
 bool InlineTextBox::isLineBreak() const {
   return getLineLayoutItem().isBR() ||
          (getLineLayoutItem().style()->preserveNewline() && len() == 1 &&
           (*getLineLayoutItem().text().impl())[start()] == '\n');
 }
@@ skipping 282 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