Add fade eliding for Views Labels; related cleanup.

ui/gfx/canvas_skia.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/canvas.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/font_list.h"
@@ skipping 66 matching lines @@
       *bitmap.getAddr32(x, y - 1) != 0)
     return true;  // Touched pixel above.
   if (y < bitmap.height() - 1 &&
       *bitmap.getAddr32(x, y + 1) != halo_color &&
       *bitmap.getAddr32(x, y + 1) != 0)
     return true;  // Touched pixel below.
   return false;
 }
 
 // Strips accelerator character prefixes in |text| if needed, based on |flags|.
-// Returns a range in |text| to underline or gfx::Range::InvalidRange() if
+// Returns a range in |text| to underline or Range::InvalidRange() if
 // underlining is not needed.
 Range StripAcceleratorChars(int flags, base::string16* text) {
   if (flags & (Canvas::SHOW_PREFIX | Canvas::HIDE_PREFIX)) {
     int char_pos = -1;
     int char_span = 0;
     *text = RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
     if ((flags & Canvas::SHOW_PREFIX) && char_pos != -1)
       return Range(char_pos, char_pos + char_span);
   }
   return Range::InvalidRange();
 }
 
 // Elides |text| and adjusts |range| appropriately. If eliding causes |range|
 // to no longer point to the same character in |text|, |range| is made invalid.
 void ElideTextAndAdjustRange(const FontList& font_list,
                              int width,
                              base::string16* text,
                              Range* range) {
   const base::char16 start_char =
       (range->IsValid() ? text->at(range->start()) : 0);
-  *text = gfx::ElideText(*text, font_list, width, gfx::ELIDE_AT_END);
+  *text = ElideText(*text, font_list, width, ELIDE_TAIL);
   if (!range->IsValid())
     return;
   if (range->start() >= text->length() ||
       text->at(range->start()) != start_char) {
     *range = Range::InvalidRange();
   }
 }
 
 // Updates |render_text| from the specified parameters.
 void UpdateRenderText(const Rect& rect,
@@ skipping 45 matching lines @@
                              int flags) {
   DCHECK_GE(*width, 0);
   DCHECK_GE(*height, 0);
 
   base::string16 adjusted_text = text;
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   if ((flags & MULTI_LINE) && *width != 0) {
-    gfx::WordWrapBehavior wrap_behavior = gfx::TRUNCATE_LONG_WORDS;
+    WordWrapBehavior wrap_behavior = TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
-      wrap_behavior = gfx::WRAP_LONG_WORDS;
+      wrap_behavior = WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = gfx::ELIDE_LONG_WORDS;
+      wrap_behavior = ELIDE_LONG_WORDS;
 
     Rect rect(*width, INT_MAX);
     std::vector<base::string16> strings;
-    gfx::ElideRectangleText(adjusted_text, font_list,
-                           rect.width(), rect.height(),
-                           wrap_behavior, &strings);
+    ElideRectangleText(adjusted_text, font_list, rect.width(), rect.height(),
+                       wrap_behavior, &strings);
     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
     UpdateRenderText(rect, base::string16(), font_list, flags, 0,
                      render_text.get());
 
     float h = 0;
     float w = 0;
     for (size_t i = 0; i < strings.size(); ++i) {
       StripAcceleratorChars(flags, &strings[i]);
       render_text->SetText(strings[i]);
       const SizeF& string_size = render_text->GetStringSizeF();
@@ skipping 42 matching lines @@
   base::string16 adjusted_text = text;
 
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetTextShadows(shadows);
 
   if (flags & MULTI_LINE) {
-    gfx::WordWrapBehavior wrap_behavior = gfx::IGNORE_LONG_WORDS;
+    WordWrapBehavior wrap_behavior = IGNORE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
-      wrap_behavior = gfx::WRAP_LONG_WORDS;
+      wrap_behavior = WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
-      wrap_behavior = gfx::ELIDE_LONG_WORDS;
+      wrap_behavior = ELIDE_LONG_WORDS;
 
     std::vector<base::string16> strings;
-    gfx::ElideRectangleText(adjusted_text,
-                           font_list,
-                           text_bounds.width(), text_bounds.height(),
-                           wrap_behavior,
-                           &strings);
+    ElideRectangleText(adjusted_text, font_list, text_bounds.width(),
+                       text_bounds.height(), wrap_behavior, &strings);
 
     for (size_t i = 0; i < strings.size(); i++) {
       Range range = StripAcceleratorChars(flags, &strings[i]);
       UpdateRenderText(rect, strings[i], font_list, flags, color,
                        render_text.get());
       int line_padding = 0;
       if (line_height > 0)
         line_padding = line_height - render_text->GetStringSize().height();
       else
         line_height = render_text->GetStringSize().height();
@@ skipping 18 matching lines @@
   } else {
     Range range = StripAcceleratorChars(flags, &adjusted_text);
     bool elide_text = ((flags & NO_ELLIPSIS) == 0);
 
 #if defined(OS_LINUX)
     // On Linux, eliding really means fading the end of the string. But only
     // for LTR text. RTL text is still elided (on the left) with "...".
     if (elide_text) {
       render_text->SetText(adjusted_text);
       if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
-        render_text->set_fade_tail(true);
+        render_text->SetElideBehavior(FADE_TAIL);
         elide_text = false;
       }
     }
 #endif
 
     if (elide_text) {
-      ElideTextAndAdjustRange(font_list,
-                              text_bounds.width(),
-                              &adjusted_text,
+      ElideTextAndAdjustRange(font_list, text_bounds.width(), &adjusted_text,
                               &range);
     }
 
     UpdateRenderText(rect, adjusted_text, font_list, flags, color,
                      render_text.get());
 
     const int text_height = render_text->GetStringSize().height();
-    // Center the text vertically.
     rect += Vector2d(0, (text_bounds.height() - text_height) / 2);
     rect.set_height(text_height);
     render_text->SetDisplayRect(rect);
     if (range.IsValid())
       render_text->ApplyStyle(UNDERLINE, true, range);
     render_text->Draw(this);
   }
 
   canvas_->restore();
 }
@@ skipping 39 matching lines @@
       }
     }
   }
 
   // Draw the halo bitmap with blur.
   ImageSkia text_image = ImageSkia(ImageSkiaRep(text_bitmap,
       text_canvas.image_scale()));
   DrawImageInt(text_image, display_rect.x() - 1, display_rect.y() - 1);
 }
 
-void Canvas::DrawFadeTruncatingStringRect(
-    const base::string16& text,
-    TruncateFadeMode truncate_mode,
-    const FontList& font_list,
-    SkColor color,
-    const Rect& display_rect) {
-  DrawFadeTruncatingStringRectWithFlags(
-      text, truncate_mode, font_list, color, display_rect, NO_ELLIPSIS);
-}
-
-void Canvas::DrawFadeTruncatingStringRectWithFlags(
-    const base::string16& text,
-    TruncateFadeMode truncate_mode,
-    const FontList& font_list,
-    SkColor color,
-    const Rect& display_rect,
-    int flags) {
+void Canvas::DrawFadedString(const base::string16& text,
+                             const FontList& font_list,
+                             SkColor color,
+                             const Rect& display_rect,
+                             int flags) {
   // If the whole string fits in the destination then just draw it directly.
   if (GetStringWidth(text, font_list) <= display_rect.width()) {
     DrawStringRectWithFlags(text, font_list, color, display_rect, flags);
     return;
   }
 
+  // Align to content directionality instead of centering and fading both ends.
+  if (!(flags & TEXT_ALIGN_LEFT) && !(flags & TEXT_ALIGN_RIGHT)) {
+    flags &= ~TEXT_ALIGN_CENTER;
+    const bool is_rtl = base::i18n::GetFirstStrongCharacterDirection(text) ==
+                        base::i18n::RIGHT_TO_LEFT;
+    flags |= is_rtl ? TEXT_ALIGN_RIGHT : TEXT_ALIGN_LEFT;
+  }
+  flags |= NO_ELLIPSIS;
+
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-  const bool is_rtl = base::i18n::GetFirstStrongCharacterDirection(text) ==
-                      base::i18n::RIGHT_TO_LEFT;
-
-  switch (truncate_mode) {
-    case TruncateFadeTail:
-      render_text->set_fade_tail(true);
-      if (is_rtl)
-        flags |= TEXT_ALIGN_RIGHT;
-      break;
-    case TruncateFadeHead:
-      render_text->set_fade_head(true);
-      if (!is_rtl)
-        flags |= TEXT_ALIGN_RIGHT;
-      break;
-  }
-
-  // Default to left alignment unless right alignment was chosen above.
-  if (!(flags & TEXT_ALIGN_RIGHT))
-    flags |= TEXT_ALIGN_LEFT;
-
   Rect rect = display_rect;
   UpdateRenderText(rect, text, font_list, flags, color, render_text.get());
+  render_text->SetElideBehavior(FADE_TAIL);
 
   const int line_height = render_text->GetStringSize().height();
-  // Center the text vertically.
   rect += Vector2d(0, (display_rect.height() - line_height) / 2);
   rect.set_height(line_height);
   render_text->SetDisplayRect(rect);
 
   canvas_->save();
   ClipRect(display_rect);
   render_text->Draw(this);
   canvas_->restore();
 }
 
 }  // namespace gfx