Implement eliding/truncating at end in RenderText

ui/gfx/render_text.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/render_text.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/gfx/text_elider.h"
+#include "ui/gfx/text_utils.h"
 #include "ui/gfx/utf16_indexing.h"
 
 namespace gfx {
 
 namespace {
 
 // All chars are replaced by this char when the password style is set.
 // TODO(benrg): GTK uses the first of U+25CF, U+2022, U+2731, U+273A, '*'
 // that's available in the font (find_invisible_char() in gtkentry.c).
 const base::char16 kPasswordReplacementChar = '*';
@@ skipping 326 matching lines @@
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
 
   // Invalidate the cached text direction if it depends on the text contents.
   if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
     text_direction_ = base::i18n::UNKNOWN_DIRECTION;
 
   obscured_reveal_index_ = -1;
   UpdateLayoutText();
-  ResetLayout();
 }
 
 void RenderText::SetHorizontalAlignment(HorizontalAlignment alignment) {
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
@@ skipping 25 matching lines @@
   insert_mode_ = !insert_mode_;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::SetObscured(bool obscured) {
   if (obscured != obscured_) {
     obscured_ = obscured;
     obscured_reveal_index_ = -1;
     cached_bounds_and_offset_valid_ = false;
     UpdateLayoutText();
-    ResetLayout();
   }
 }
 
 void RenderText::SetObscuredRevealIndex(int index) {
   if (obscured_reveal_index_ == index)
     return;
 
   obscured_reveal_index_ = index;
   cached_bounds_and_offset_valid_ = false;
   UpdateLayoutText();
-  ResetLayout();
 }
 
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
   }
 }
 
+void RenderText::SetElideBehavior(ElideBehavior elide_behavior) {
+  elide_behavior_ = elide_behavior;
+  if (elide_behavior_ != gfx::NO_ELIDE)

[msw, 2013/12/12 19:28:29]

This should check if the elide behavior changed, and run even if it was changed
from ELIDE_AT_END to NO_ELIDE. 

[Anuj, 2013/12/13 01:23:50]

Good point. Thanks.

+    UpdateLayoutText();
+}
+
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   lines_.clear();
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
@@ skipping 377 matching lines @@
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
       colors_(kDefaultColor),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
+      elide_behavior_(NO_ELIDE),
       multiline_(false),
       fade_head_(false),
       fade_tail_(false),
       background_is_transparent_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
       cached_bounds_and_offset_valid_(false) {
 }
 
 const Vector2d& RenderText::GetUpdatedDisplayOffset() {
@@ skipping 259 matching lines @@
       U16_NEXT(text_.data(), end, text_.length(), unused_char);
 
       // Gets the index in |layout_text_| to be replaced.
       const size_t cp_start =
           static_cast<size_t>(gfx::UTF16IndexToOffset(text_, 0, start));
       if (layout_text_.length() > cp_start)
         layout_text_.replace(cp_start, 1, text_.substr(start, end - start));
     }
   }
 
-  const base::string16& text = obscured_ ? layout_text_ : text_;
+  const base::string16& text = GetLayoutText();
   if (truncate_length_ > 0 && truncate_length_ < text.length()) {
     // Truncate the text at a valid character break and append an ellipsis.
     icu::StringCharacterIterator iter(text.c_str());
     iter.setIndex32(truncate_length_ - 1);
     layout_text_.assign(text.substr(0, iter.getIndex()) + gfx::kEllipsisUTF16);
   }
+
+  int content_width = GetContentWidth();

[msw, 2013/12/12 19:28:29]

Inline this, it's value is only needed once, conditionally.

[Anuj, 2013/12/13 01:23:50]

Done.

+  if (elide_behavior_ != NO_ELIDE && display_rect_.width() > 0 &&
+      content_width > display_rect_.width()) {
+    base::string16 elided_text = ElideText(GetLayoutText());
+
+    // This doesn't trim styles so ellipsis may get rendered as a different
+    // style than the preceding text. See crbug.com/327850.
+    layout_text_.assign(elided_text);
+  }
+  ResetLayout();
+}
+
+// TODO(skanuj): Fix code duplication with ElideText in ui/gfx/text_elider.cc
+// See crbug.com/327846
+base::string16 RenderText::ElideText(const base::string16& text) {
+  if (text.empty())
+    return text;
+
+  const bool insert_ellipsis = (elide_behavior_ != TRUNCATE_AT_END);
+  // Create a copy render text. We copy the attributes which affect the

[msw, 2013/12/12 19:28:29]

optional nit: // Create a RenderText copy with attributes that affect the
rendering width.

[Anuj, 2013/12/13 01:23:50]

Done.

+  // rendering width.
+  scoped_ptr<RenderText> render_text(CreateInstance());
+  render_text->SetFontList(font_list_);
+  render_text->SetDirectionalityMode(directionality_mode_);
+  render_text->SetCursorEnabled(cursor_enabled_);
+  render_text->styles_ = styles_;
+  render_text->colors_ = colors_;
+  render_text->SetText(text);
+  const float current_text_pixel_width = render_text->GetContentWidth();
+
+  const base::string16 ellipsis = base::string16(kEllipsisUTF16);
+  const bool elide_in_middle = false;
+  StringSlicer slicer(text, ellipsis, elide_in_middle);
+
+  // Pango will return 0 width for absurdly long strings. Cut the string in
+  // half and try again.
+  // This is caused by an int overflow in Pango (specifically, in
+  // pango_glyph_string_extents_range). It's actually more subtle than just
+  // returning 0, since on super absurdly long strings, the int can wrap and
+  // return positive numbers again. Detecting that is probably not worth it
+  // (eliding way too much from a ridiculous string is probably still
+  // ridiculous), but we should check other widths for bogus values as well.
+  if (current_text_pixel_width <= 0 && !text.empty())
+    return ElideText(slicer.CutString(text.length() / 2, insert_ellipsis));
+
+  if (current_text_pixel_width <= display_rect_.width())
+    return text;
+
+  if (insert_ellipsis &&
+      GetStringWidthF(ellipsis, font_list_) > display_rect_.width())
+    return base::string16();
+
+  // Use binary search to compute the elided text.
+  size_t lo = 0;
+  size_t hi = text.length() - 1;
+
+  for (size_t guess = (lo + hi) / 2; lo <= hi; guess = (lo + hi) / 2) {
+    // Restore styles and colors. They will be truncated to size by SetText.
+    render_text->styles_ = styles_;
+    render_text->colors_ = colors_;
+    base::string16 new_text = slicer.CutString(guess, false);
+    render_text->SetText(new_text);

[msw, 2013/12/12 19:28:29]

Oh darn, I think you'll need to (conditionally?) reapply the original styles and
colors here, because otherwise if a short guess truncates styles applied to the
end of the string, and then another loop pass restores some of that string
length, it'll ignore the intended styles for that range...

[Anuj, 2013/12/13 01:23:50]

No. The unconditional reapplying of original styles works fine. Note that we are
restoring from original styles which are not getting modified, and correspond to
the full text length. And assignment is creating a copy if that is your doubt.

[msw, 2013/12/13 01:56:08]

Gah, I just missed copying done above... Sorry for the false alarm.

[Anuj, 2013/12/13 02:23:45]

Done.

+
+    // This has to be an additional step so that the ellipsis is rendered with
+    // same style as trailing part of the text.
+    if (insert_ellipsis) {
+

[msw, 2013/12/12 19:28:29]

nit: remove this blank line.

[Anuj, 2013/12/13 01:23:50]

Done.

+      // When ellipsis follows text whose directionality is not the same as that
+      // of the whole text, it will be rendered with the directionality of the
+      // whole text. Since we want ellipsis to indicate continuation of the
+      // preceding text, we force the directionality of ellipsis to be same as
+      // the preceding text using LTR or RTL markers.
+      base::i18n::TextDirection leading_text_direction =
+          base::i18n::GetFirstStrongCharacterDirection(new_text);
+      base::i18n::TextDirection trailing_text_direction =
+          base::i18n::GetLastStrongCharacterDirection(new_text);
+      new_text += ellipsis;
+      if (trailing_text_direction != leading_text_direction) {
+        if (trailing_text_direction == base::i18n::LEFT_TO_RIGHT)
+          new_text += base::i18n::kLeftToRightMark;
+        else
+          new_text += base::i18n::kRightToLeftMark;
+      }
+      render_text->SetText(new_text);
+    }
+
+    // We check the width of the whole desired string at once to ensure we
+    // handle kerning/ligatures/etc. correctly.
+    const int guess_width = render_text->GetContentWidth();
+    if (guess_width == display_rect_.width())
+      break;
+    if (guess_width > display_rect_.width()) {
+      hi = guess - 1;
+      // Move back if we are on loop terminating condition, and guess is wider
+      // than available.
+      if (hi < lo)
+        lo = hi;
+    } else {
+      lo = guess + 1;
+    }
+  }
+
+  return render_text->text();
 }
 
 void RenderText::UpdateCachedBoundsAndOffset() {
   if (cached_bounds_and_offset_valid_)
     return;
 
   // TODO(ckocagil): Add support for scrolling multiline text.
 
   // First, set the valid flag true to calculate the current cursor bounds using
   // the stale |display_offset_|. Applying |delta_offset| at the end of this
@@ skipping 38 matching lines @@
   cursor_bounds_ += delta_offset;
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx