Add fade eliding for Views Labels; related cleanup.

ui/gfx/text_elider.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.
 //
 // This file implements utility functions for eliding and formatting UI text.
 //
 // Note that several of the functions declared in text_elider.h are implemented
 // in this file using helper classes in an unnamed namespace.
 
 #include "ui/gfx/text_elider.h"
@@ skipping 14 matching lines @@
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/text_utils.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 
 namespace gfx {
 
-// U+2026 in utf8
-const char kEllipsis[] = "\xE2\x80\xA6";
-const base::char16 kEllipsisUTF16[] = { 0x2026, 0 };
-const base::char16 kForwardSlash = '/';
+namespace {
 
-StringSlicer::StringSlicer(const base::string16& text,
-             const base::string16& ellipsis,
-             bool elide_in_middle,
-             bool elide_at_beginning)
-    : text_(text),
-      ellipsis_(ellipsis),
-      elide_in_middle_(elide_in_middle),
-      elide_at_beginning_(elide_at_beginning) {
-}
-
-base::string16 StringSlicer::CutString(size_t length, bool insert_ellipsis) {
-  const base::string16 ellipsis_text = insert_ellipsis ? ellipsis_
-                                                       : base::string16();
-
-  if (elide_at_beginning_)
-    return ellipsis_text +
-           text_.substr(FindValidBoundaryBefore(text_.length() - length));
-
-  if (!elide_in_middle_)
-    return text_.substr(0, FindValidBoundaryBefore(length)) + ellipsis_text;
-
-  // We put the extra character, if any, before the cut.
-  const size_t half_length = length / 2;
-  const size_t prefix_length = FindValidBoundaryBefore(length - half_length);
-  const size_t suffix_start_guess = text_.length() - half_length;
-  const size_t suffix_start = FindValidBoundaryAfter(suffix_start_guess);
-  const size_t suffix_length =
-      half_length - (suffix_start_guess - suffix_start);
-  return text_.substr(0, prefix_length) + ellipsis_text +
-         text_.substr(suffix_start, suffix_length);
-}
-
-size_t StringSlicer::FindValidBoundaryBefore(size_t index) const {
-  DCHECK_LE(index, text_.length());
-  if (index != text_.length())
-    U16_SET_CP_START(text_.data(), 0, index);
-  return index;
-}
-
-size_t StringSlicer::FindValidBoundaryAfter(size_t index) const {
-  DCHECK_LE(index, text_.length());
-  if (index != text_.length())
-    U16_SET_CP_LIMIT(text_.data(), 0, index, text_.length());
-  return index;
-}
-
+// Elides a well-formed email address (e.g. username@domain.com) to fit into
+// |available_pixel_width| using the specified |font_list|.
+// This function guarantees that the string returned will contain at least one
+// character, other than the ellipses, on either side of the '@'. If it is
+// impossible to achieve these requirements: only an ellipsis will be returned.
+// If possible: this elides only the username portion of the |email|. Otherwise,
+// the domain is elided in the middle so that it splits the available width
+// equally with the elided username (should the username be short enough that it
+// doesn't need half the available width: the elided domain will occupy that
+// extra width).
 base::string16 ElideEmail(const base::string16& email,
                           const FontList& font_list,
                           float available_pixel_width) {
   if (GetStringWidthF(email, font_list) <= available_pixel_width)
     return email;
 
   // Split the email into its local-part (username) and domain-part. The email
   // spec technically allows for @ symbols in the local-part (username) of the
   // email under some special requirements. It is guaranteed that there is no @
   // symbol in the domain part of the email however so splitting at the last @
@@ skipping 21 matching lines @@
     // Elide the domain so that it only takes half of the available width.
     // Should the username not need all the width available in its half, the
     // domain will occupy the leftover width.
     // If |desired_domain_width| is greater than |available_domain_width|: the
     // minimal username elision allowed by the specifications will not fit; thus
     // |desired_domain_width| must be <= |available_domain_width| at all cost.
     const float desired_domain_width =
         std::min(available_domain_width,
                  std::max(available_pixel_width - full_username_width,
                           available_pixel_width / 2));
-    domain = ElideText(domain, font_list, desired_domain_width,
-                       ELIDE_IN_MIDDLE);
+    domain = ElideText(domain, font_list, desired_domain_width, ELIDE_MIDDLE);
     // Failing to elide the domain such that at least one character remains
     // (other than the ellipsis itself) remains: return a single ellipsis.
     if (domain.length() <= 1U)
       return base::string16(kEllipsisUTF16);
   }
 
   // Fit the username in the remaining width (at this point the elided username
   // is guaranteed to fit with at least one character remaining given all the
   // precautions taken earlier).
   available_pixel_width -= GetStringWidthF(domain, font_list);
-  username = ElideText(username, font_list, available_pixel_width,
-                       ELIDE_AT_END);
+  username = ElideText(username, font_list, available_pixel_width, ELIDE_TAIL);
+  return username + kAtSignUTF16 + domain;
+}
 
-  return username + kAtSignUTF16 + domain;
+}  // namespace
+
+// U+2026 in utf8
+const char kEllipsis[] = "\xE2\x80\xA6";
+const base::char16 kEllipsisUTF16[] = { 0x2026, 0 };
+const base::char16 kForwardSlash = '/';
+
+StringSlicer::StringSlicer(const base::string16& text,
+                           const base::string16& ellipsis,
+                           bool elide_in_middle,
+                           bool elide_at_beginning)
+    : text_(text),
+      ellipsis_(ellipsis),
+      elide_in_middle_(elide_in_middle),
+      elide_at_beginning_(elide_at_beginning) {
+}
+
+base::string16 StringSlicer::CutString(size_t length, bool insert_ellipsis) {
+  const base::string16 ellipsis_text = insert_ellipsis ? ellipsis_
+                                                       : base::string16();
+
+  if (elide_at_beginning_)
+    return ellipsis_text +
+           text_.substr(FindValidBoundaryBefore(text_.length() - length));
+
+  if (!elide_in_middle_)
+    return text_.substr(0, FindValidBoundaryBefore(length)) + ellipsis_text;
+
+  // We put the extra character, if any, before the cut.
+  const size_t half_length = length / 2;
+  const size_t prefix_length = FindValidBoundaryBefore(length - half_length);
+  const size_t suffix_start_guess = text_.length() - half_length;
+  const size_t suffix_start = FindValidBoundaryAfter(suffix_start_guess);
+  const size_t suffix_length =
+      half_length - (suffix_start_guess - suffix_start);
+  return text_.substr(0, prefix_length) + ellipsis_text +
+         text_.substr(suffix_start, suffix_length);
+}
+
+size_t StringSlicer::FindValidBoundaryBefore(size_t index) const {
+  DCHECK_LE(index, text_.length());
+  if (index != text_.length())
+    U16_SET_CP_START(text_.data(), 0, index);
+  return index;
+}
+
+size_t StringSlicer::FindValidBoundaryAfter(size_t index) const {
+  DCHECK_LE(index, text_.length());
+  if (index != text_.length())
+    U16_SET_CP_LIMIT(text_.data(), 0, index, text_.length());
+  return index;
 }
 
 base::string16 ElideFilename(const base::FilePath& filename,
                              const FontList& font_list,
                              float available_pixel_width) {
 #if defined(OS_WIN)
   base::string16 filename_utf16 = filename.value();
   base::string16 extension = filename.Extension();
   base::string16 rootname = filename.BaseName().RemoveExtension().value();
 #elif defined(OS_POSIX)
   base::string16 filename_utf16 = WideToUTF16(base::SysNativeMBToWide(
       filename.value()));
   base::string16 extension = WideToUTF16(base::SysNativeMBToWide(
       filename.Extension()));
   base::string16 rootname = WideToUTF16(base::SysNativeMBToWide(
       filename.BaseName().RemoveExtension().value()));
 #endif
 
   const float full_width = GetStringWidthF(filename_utf16, font_list);
   if (full_width <= available_pixel_width)
     return base::i18n::GetDisplayStringInLTRDirectionality(filename_utf16);
 
   if (rootname.empty() || extension.empty()) {
-    const base::string16 elided_name = ElideText(filename_utf16, font_list,
-                                           available_pixel_width, ELIDE_AT_END);
+    const base::string16 elided_name =
+        ElideText(filename_utf16, font_list, available_pixel_width, ELIDE_TAIL);
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   const float ext_width = GetStringWidthF(extension, font_list);
   const float root_width = GetStringWidthF(rootname, font_list);
 
   // We may have trimmed the path.
   if (root_width + ext_width <= available_pixel_width) {
     const base::string16 elided_name = rootname + extension;
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   if (ext_width >= available_pixel_width) {
     const base::string16 elided_name = ElideText(
-        rootname + extension, font_list, available_pixel_width,
-        ELIDE_IN_MIDDLE);
+        rootname + extension, font_list, available_pixel_width, ELIDE_MIDDLE);
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   float available_root_width = available_pixel_width - ext_width;
   base::string16 elided_name =
-      ElideText(rootname, font_list, available_root_width, ELIDE_AT_END);
+      ElideText(rootname, font_list, available_root_width, ELIDE_TAIL);
   elided_name += extension;
   return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
 }
 
 base::string16 ElideText(const base::string16& text,
                          const FontList& font_list,
                          float available_pixel_width,
-                         ElideBehavior elide_behavior) {
-  if (text.empty())
+                         ElideBehavior behavior) {
+  DCHECK_NE(behavior, FADE_TAIL);
+  if (text.empty() || behavior == FADE_TAIL)
     return text;
+  if (behavior == ELIDE_EMAIL)
+    return ElideEmail(text, font_list, available_pixel_width);
 
   const float current_text_pixel_width = GetStringWidthF(text, font_list);
-  const bool elide_in_middle = (elide_behavior == ELIDE_IN_MIDDLE);
-  const bool elide_at_beginning = (elide_behavior == ELIDE_AT_BEGINNING);
-  const bool insert_ellipsis = (elide_behavior != TRUNCATE_AT_END);
-
+  const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
+  const bool elide_at_beginning = (behavior == ELIDE_HEAD);
+  const bool insert_ellipsis = (behavior != TRUNCATE);
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   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
   // (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()) {
+  if (current_text_pixel_width <= 0) {
     const base::string16 cut =
       slicer.CutString(text.length() / 2, insert_ellipsis);
-    return ElideText(cut, font_list, available_pixel_width, elide_behavior);
+    return ElideText(cut, font_list, available_pixel_width, behavior);
   }
 
   if (current_text_pixel_width <= available_pixel_width)
     return text;
 
   if (insert_ellipsis &&
       GetStringWidthF(ellipsis, font_list) > available_pixel_width)
     return base::string16();
 
   // Use binary search to compute the elided text.
@@ skipping 16 matching lines @@
       if (hi < lo)
         lo = hi;
     } else {
       lo = guess + 1;
     }
   }
 
   return slicer.CutString(guess, insert_ellipsis);
 }
 
-bool ElideString(const base::string16& input, int max_len,
+bool ElideString(const base::string16& input,
+                 int max_len,
                  base::string16* output) {
   DCHECK_GE(max_len, 0);
   if (static_cast<int>(input.length()) <= max_len) {
     output->assign(input);
     return false;
   }
 
   switch (max_len) {
     case 0:
       output->clear();
@@ skipping 358 matching lines @@
   NewLine();
 }
 
 int RectangleText::WrapWord(const base::string16& word) {
   // Word is so wide that it must be fragmented.
   base::string16 text = word;
   int lines_added = 0;
   bool first_fragment = true;
   while (!insufficient_height_ && !text.empty()) {
     base::string16 fragment =
-        ElideText(text, font_list_, available_pixel_width_,
-                  TRUNCATE_AT_END);
+        ElideText(text, font_list_, available_pixel_width_, TRUNCATE);
     // At least one character has to be added at every line, even if the
     // available space is too small.
-    if(fragment.empty())
+    if (fragment.empty())
       fragment = text.substr(0, 1);
     if (!first_fragment && NewLine())
       lines_added++;
     AddToCurrentLine(fragment);
     text = text.substr(fragment.length());
     first_fragment = false;
   }
   return lines_added;
 }
 
 int RectangleText::AddWordOverflow(const base::string16& word) {
   int lines_added = 0;
 
   // Unless this is the very first word, put it on a new line.
   if (!current_line_.empty()) {
     if (!NewLine())
       return 0;
     lines_added++;
   }
 
   if (wrap_behavior_ == IGNORE_LONG_WORDS) {
     current_line_ = word;
     current_width_ = available_pixel_width_;
   } else if (wrap_behavior_ == WRAP_LONG_WORDS) {
     lines_added += WrapWord(word);
   } else {
     const ElideBehavior elide_behavior =
-        (wrap_behavior_ == ELIDE_LONG_WORDS ? ELIDE_AT_END : TRUNCATE_AT_END);
+        (wrap_behavior_ == ELIDE_LONG_WORDS ? ELIDE_TAIL : TRUNCATE);
     const base::string16 elided_word =
         ElideText(word, font_list_, available_pixel_width_, elide_behavior);
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 int RectangleText::AddWord(const base::string16& word) {
@@ skipping 125 matching lines @@
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace gfx