Adjust text fade width and alpha

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 77 matching lines @@
 // Converts |Font::FontStyle| flags to |SkTypeface::Style| flags.
 SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
   int skia_style = SkTypeface::kNormal;
   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.
+  // Fade in/out about 3 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.
+  // Use a 1/3 of the display width if the display width is very short.
   const int average_character_width = font_list.GetExpectedTextWidth(1);

[Peter Kasting, 2015/12/03 05:29:25]

While here: Instead of getting the width of 1 char and multiplying by 3, get the
width of 3 chars.  This returns the same value save for being slightly less
prone to rounding error.

Also use this where you want 4 char widths below.

[Tomasz Moniuszko, 2015/12/03 11:18:42]

Done.

-  const double gradient_width = std::min(average_character_width * 2.5,
-                                         display_width / 4.0);
+  const double gradient_width =
+      std::min(average_character_width * 3.0, display_width / 3.0);
   DCHECK_GE(gradient_width, 0.0);
   return static_cast<int>(floor(gradient_width + 0.5));

[Peter Kasting, 2015/12/03 05:29:25]

Nit: For now, define a round() helper in this file and call that here and below
(see my comment there); I've separately sent a proposal to the C++11 arbiters to
allow std::round() from C++11.

[Tomasz Moniuszko, 2015/12/03 11:18:42]

Done.

 }
 
 // Appends to |positions| and |colors| values corresponding to the fade over
 // |fade_rect| from color |c0| to color |c1|.
 void AddFadeEffect(const Rect& text_rect,
                    const Rect& fade_rect,
                    SkColor c0,
                    SkColor c1,
                    std::vector<SkScalar>* positions,
                    std::vector<SkColor>* colors) {
   const SkScalar left = static_cast<SkScalar>(fade_rect.x() - text_rect.x());
   const SkScalar width = static_cast<SkScalar>(fade_rect.width());
   const SkScalar p0 = left / text_rect.width();
   const SkScalar p1 = (left + width) / text_rect.width();
   // Prepend 0.0 to |positions|, as required by Skia.
   if (positions->empty() && p0 != 0.0) {
     positions->push_back(0.0);
     colors->push_back(c0);
   }
   positions->push_back(p0);
   colors->push_back(c0);
   positions->push_back(p1);
   colors->push_back(c1);
 }
 
 // Creates a SkShader to fade the text, with |left_part| specifying the left
 // fade effect, if any, and |right_part| specifying the right fade effect.
-skia::RefPtr<SkShader> CreateFadeShader(const Rect& text_rect,
+skia::RefPtr<SkShader> CreateFadeShader(const FontList& font_list,
+                                        const Rect& text_rect,
                                         const Rect& left_part,
                                         const Rect& right_part,
                                         SkColor color) {
-  // Fade alpha of 51/255 corresponds to a fade of 0.2 of the original color.
-  const SkColor fade_color = SkColorSetA(color, 51);
+  // Use 0 fade target alpha. But if text is narrow (less than 4 average
+  // characters) linearly increase fade target alpha up to 51/255 what
+  // corresponds to a fade of 0.2 of the original color.
+  const int average_character_width = font_list.GetExpectedTextWidth(1);
+  int alpha =
+      text_rect.width() > 4 * average_character_width
+          ? 0
+          : static_cast<int>(
+                51 * (1 - text_rect.width() / (4.0 * average_character_width)));
+  const SkColor fade_color = SkColorSetA(color, alpha);

[Peter Kasting, 2015/12/03 05:29:25]

How about this:

  // In general, fade down to 0 alpha.  But when the available width is less
  // than four characters, linearly ramp up the fade target alpha to as high as
  // 20% at zero width.  This allows the user to see the last faded characters a
  // little better when there are only a few characters shown.
  const float width_fraction =
      text_rect.width() / static_cast<float>(font_list.GetExpectedTextWidth(4));
  const SkAlpha kAlphaAtZeroWidth = 51;
  const SkAlpha alpha = (width_fraction < 1) ?
      static_cast<SkAlpha>(round((1 - width_fraction) * kAlphaAtZeroWidth)) : 0;
  const SkColor fade_color = SkColorSetA(color, alpha);

[Tomasz Moniuszko, 2015/12/03 11:18:42]

Done.

   std::vector<SkScalar> positions;
   std::vector<SkColor> colors;
 
   if (!left_part.IsEmpty())
     AddFadeEffect(text_rect, left_part, fade_color, color,
                   &positions, &colors);
   if (!right_part.IsEmpty())
     AddFadeEffect(text_rect, right_part, color, fade_color,
                   &positions, &colors);
   DCHECK(!positions.empty());
@@ skipping 1053 matching lines @@
   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(
-      text_rect, left_part, right_part, colors_.breaks().front().second);
+  skia::RefPtr<SkShader> shader =
+      CreateFadeShader(font_list(), text_rect, left_part, right_part,
+                       colors_.breaks().front().second);
   if (shader)
     renderer->SetShader(shader.get());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
 base::i18n::TextDirection RenderText::GetTextDirection(
@@ skipping 297 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx