Add fade eliding for Views Labels; related cleanup.

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/command_line.h"
@@ skipping 60 matching lines @@
   // Some platforms don't support getting the cap height, and simply return
   // the entire font ascent from GetCapHeight().  Centering the ascent makes
   // the font look too low, so if GetCapHeight() returns the ascent, center
   // the entire font height instead.
   const int space =
       display_height - ((internal_leading != 0) ? cap_height : font_height);
   const int baseline_shift = space / 2 - internal_leading;
   return baseline + std::max(min_shift, std::min(max_shift, baseline_shift));
 }
 
-// Converts |gfx::Font::FontStyle| flags to |SkTypeface::Style| flags.
+// Converts |Font::FontStyle| flags to |SkTypeface::Style| flags.
 SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
   int skia_style = SkTypeface::kNormal;
-  skia_style |= (font_style & gfx::Font::BOLD) ? SkTypeface::kBold : 0;
-  skia_style |= (font_style & gfx::Font::ITALIC) ? SkTypeface::kItalic : 0;
+  skia_style |= (font_style & Font::BOLD) ? SkTypeface::kBold : 0;
+  skia_style |= (font_style & Font::ITALIC) ? SkTypeface::kItalic : 0;
   return static_cast<SkTypeface::Style>(skia_style);
 }
 
 // Given |font| and |display_width|, returns the width of the fade gradient.
 int CalculateFadeGradientWidth(const FontList& font_list, int display_width) {
   // Fade in/out about 2.5 characters of the beginning/end of the string.
   // The .5 here is helpful if one of the characters is a space.
   // Use a quarter of the display width if the display width is very short.
   const int average_character_width = font_list.GetExpectedTextWidth(1);
   const double gradient_width = std::min(average_character_width * 2.5,
@@ skipping 126 matching lines @@
                                               int style) {
   DCHECK(!family.empty());
 
   skia::RefPtr<SkTypeface> typeface = CreateSkiaTypeface(family.c_str(), style);
   if (typeface) {
     // |paint_| adds its own ref. So don't |release()| it from the ref ptr here.
     SetTypeface(typeface.get());
 
     // Enable fake bold text if bold style is needed but new typeface does not
     // have it.
-    paint_.setFakeBoldText((style & gfx::Font::BOLD) && !typeface->isBold());
+    paint_.setFakeBoldText((style & Font::BOLD) && !typeface->isBold());
   }
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
 }
 
 void SkiaTextRenderer::SetShader(SkShader* shader, const Rect& bounds) {
   bounds_ = RectToSkRect(bounds);
   paint_.setShader(shader);
@@ skipping 259 matching lines @@
     UpdateLayoutText();
   }
 }
 
 void RenderText::SetDisplayRect(const Rect& r) {
   if (r != display_rect_) {
     display_rect_ = r;
     baseline_ = kInvalidBaseline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
-    if (elide_behavior_ != gfx::NO_ELIDE)
+    if (elide_behavior_ != TRUNCATE)
       UpdateLayoutText();
   }
 }
 
 void RenderText::SetCursorPosition(size_t position) {
   MoveCursorTo(position, false);
 }
 
 void RenderText::MoveCursor(BreakType break_type,
                             VisualCursorDirection direction,
@@ skipping 360 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),
+      elide_behavior_(TRUNCATE),
       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() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
@@ skipping 160 matching lines @@
         lines_.back().size.height();
     offset.set_y((display_rect_.height() - text_height) / 2);
   } else {
     offset.set_y(GetBaseline() - GetLayoutTextBaseline());
   }
 
   return offset;
 }
 
 void RenderText::ApplyFadeEffects(internal::SkiaTextRenderer* renderer) {
-  if (multiline() || (!fade_head() && !fade_tail()))
+  const int width = display_rect().width();
+  if (multiline() || elide_behavior_ != FADE_TAIL || GetContentWidth() <= width)
     return;
 
-  const int display_width = display_rect().width();
-
-  // If the text fits as-is, no need to fade.
-  if (GetStringSize().width() <= display_width)
-    return;
-
-  int gradient_width = CalculateFadeGradientWidth(font_list(), display_width);
+  const int gradient_width = CalculateFadeGradientWidth(font_list(), width);
   if (gradient_width == 0)
     return;
 
-  bool fade_left = fade_head();
-  bool fade_right = fade_tail();
-  // Under RTL, |fade_right| == |fade_head|.
-  // TODO(asvitkine): This is currently not based on GetTextDirection() because
-  //                  RenderTextWin does not return a direction that's based on
-  //                  the text content.
-  if (horizontal_alignment_ == ALIGN_RIGHT)
-    std::swap(fade_left, fade_right);
-
   Rect solid_part = display_rect();
   Rect left_part;
   Rect right_part;
-  if (fade_left) {
+  if (horizontal_alignment_ != ALIGN_LEFT) {
     left_part = solid_part;
     left_part.Inset(0, 0, solid_part.width() - gradient_width, 0);
     solid_part.Inset(gradient_width, 0, 0, 0);
   }
-  if (fade_right) {
+  if (horizontal_alignment_ != ALIGN_RIGHT) {
     right_part = solid_part;
     right_part.Inset(solid_part.width() - gradient_width, 0, 0, 0);
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
   skia::RefPtr<SkShader> shader = CreateFadeShader(
@@ skipping 24 matching lines @@
         Range(select ? selection().start() : cursor, cursor),
         (cursor == 0) ? CURSOR_FORWARD : CURSOR_BACKWARD));
 }
 
 void RenderText::UpdateLayoutText() {
   layout_text_.clear();
   line_breaks_.SetMax(0);
 
   if (obscured_) {
     size_t obscured_text_length =
-        static_cast<size_t>(gfx::UTF16IndexToOffset(text_, 0, text_.length()));
+        static_cast<size_t>(UTF16IndexToOffset(text_, 0, text_.length()));
     layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
 
     if (obscured_reveal_index_ >= 0 &&
         obscured_reveal_index_ < static_cast<int>(text_.length())) {
       // Gets the index range in |text_| to be revealed.
       size_t start = obscured_reveal_index_;
       U16_SET_CP_START(text_.data(), 0, start);
       size_t end = start;
       UChar32 unused_char;
       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));
+          static_cast<size_t>(UTF16IndexToOffset(text_, 0, start));
       if (layout_text_.length() > cp_start)
         layout_text_.replace(cp_start, 1, text_.substr(start, end - start));
     }
   } else {
     layout_text_ = text_;
   }
 
   const base::string16& text = layout_text_;
   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);
+    layout_text_.assign(text.substr(0, iter.getIndex()) + kEllipsisUTF16);
   }
 
-  if (elide_behavior_ != NO_ELIDE && display_rect_.width() > 0 &&
-      !layout_text_.empty() && GetContentWidth() > display_rect_.width()) {
+  if (elide_behavior_ != TRUNCATE && elide_behavior_ != FADE_TAIL &&
+      display_rect_.width() > 0 && !layout_text_.empty() &&
+      GetContentWidth() > display_rect_.width()) {
     // 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(ElideText(layout_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) {
-  const bool insert_ellipsis = (elide_behavior_ != TRUNCATE_AT_END);
+  const bool insert_ellipsis = (elide_behavior_ != TRUNCATE);
   // Create a RenderText copy with attributes that affect the 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 int current_text_pixel_width = render_text->GetContentWidth();
 
-  const base::string16 ellipsis = base::string16(gfx::kEllipsisUTF16);
+  const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool elide_in_middle = false;
   const bool elide_at_beginning = false;
   StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
 
   // 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
@@ skipping 112 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