aura: Really long tooltips should be wrapped not truncated.

ash/tooltips/tooltip_controller.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 "ash/tooltips/tooltip_controller.h"
 
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
@@ skipping 15 matching lines @@
 #include "ui/views/border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 const SkColor kTooltipBackground = 0xFFFFFFCC;
 const SkColor kTooltipBorder = 0xFF646450;
 const int kTooltipBorderWidth = 1;
 const int kTooltipHorizontalPadding = 3;
+
+// Max visual tooltip width. If a tooltip is greater than this width, it will
+// be wrapped.
+const int kTooltipMaxWidthPixels = 400;
+
+// Maximum number of lines we allow in the tooltip.
+const size_t kMaxLines = 10;
+
 // TODO(derat): This padding is needed on Chrome OS devices but seems excessive
 // when running the same binary on a Linux workstation; presumably there's a
 // difference in font metrics.  Rationalize this.
 const int kTooltipVerticalPadding = 2;
 const int kTooltipTimeoutMs = 500;
 
 // FIXME: get cursor offset from actual cursor size.
 const int kCursorOffsetX = 10;
 const int kCursorOffsetY = 15;
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
-// Maximum number of lines we allow in the tooltip.
-const size_t kMaxLines = 6;
-
 gfx::Font GetDefaultFont() {
   // TODO(varunjain): implementation duplicated in tooltip_manager_aura. Figure
   // out a way to merge.
   return ui::ResourceBundle::GetSharedInstance().GetFont(
       ui::ResourceBundle::BaseFont);
 }
 
 int GetMaxWidth(int x, int y) {
   // TODO(varunjain): implementation duplicated in tooltip_manager_aura. Figure
   // out a way to merge.
   gfx::Rect monitor_bounds =
       gfx::Screen::GetMonitorAreaNearestPoint(gfx::Point(x, y));
   return (monitor_bounds.width() + 1) / 2;
 }
 
-// Trims the tooltip to fit, setting |text| to the clipped result,
-// |max_width| to the width (in pixels) of the clipped text and |line_count|
-// to the number of lines of text in the tooltip. |x| and |y| give the
-// location of the tooltip in screen coordinates.
-void TrimTooltipToFit(string16* text,
-                      int* max_width,
-                      int* line_count,
-                      int x,
-                      int y) {
-  *max_width = 0;
-  *line_count = 0;
-
-  // Clamp the tooltip length to kMaxTooltipLength so that we don't
-  // accidentally DOS the user with a mega tooltip.
-  if (text->length() > kMaxTooltipLength)
-    *text = text->substr(0, kMaxTooltipLength);
-
-  // Determine the available width for the tooltip.
-  int available_width = GetMaxWidth(x, y);
-
-  // Split the string into at most kMaxLines lines.
-  std::vector<string16> lines;
-  base::SplitString(*text, '\n', &lines);
-  if (lines.size() > kMaxLines)
-    lines.resize(kMaxLines);
-  *line_count = static_cast<int>(lines.size());
-
-  // Format each line to fit.
-  gfx::Font font = GetDefaultFont();
-  string16 result;
-  for (std::vector<string16>::iterator i = lines.begin(); i != lines.end();
-       ++i) {
-    string16 elided_text =
-        ui::ElideText(*i, font, available_width, ui::ELIDE_AT_END);
-    *max_width = std::max(*max_width, font.GetStringWidth(elided_text));
-    if (!result.empty())
-      result.push_back('\n');
-    result.append(elided_text);
-  }
-  *text = result;
-}
-
 // Creates a widget of type TYPE_TOOLTIP
 views::Widget* CreateTooltip() {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params;
   // For aura, since we set the type to TOOLTIP_TYPE, the widget will get
   // auto-parented to the MenuAndTooltipsContainer.
   params.type = views::Widget::InitParams::TYPE_TOOLTIP;
   params.keep_on_top = true;
   params.accept_events = false;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
@@ skipping 194 matching lines @@
   return ui::GESTURE_STATUS_UNKNOWN;
 }
 
 void TooltipController::OnWindowDestroyed(aura::Window* window) {
   if (tooltip_window_ == window) {
     tooltip_window_->RemoveObserver(this);
     tooltip_window_ = NULL;
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// TooltipController private:
+
+// static
+void TooltipController::TrimTooltipToFit(string16* text,
+                                         int* max_width,
+                                         int* line_count,
+                                         int x,
+                                         int y) {
+  *max_width = 0;
+  *line_count = 0;
+
+  // Clamp the tooltip length to kMaxTooltipLength so that we don't
+  // accidentally DOS the user with a mega tooltip.
+  if (text->length() > kMaxTooltipLength)
+    *text = text->substr(0, kMaxTooltipLength);
+
+  // Determine the available width for the tooltip.
+  int available_width = std::min(kTooltipMaxWidthPixels, GetMaxWidth(x, y));
+
+  std::vector<string16> lines;
+  base::SplitString(*text, '\n', &lines);
+  std::vector<string16> result_lines;
+
+  // Format each line to fit.
+  gfx::Font font = GetDefaultFont();
+  for (std::vector<string16>::iterator l = lines.begin(); l != lines.end();
+      ++l) {
+    // We break the line at word boundaries, then stuff as many words as we can
+    // in the available width to the current line, and move the remaining words
+    // to a new line.
+    std::vector<string16> words;
+    base::SplitStringDontTrim(*l, ' ', &words);
+    int current_width = 0;
+    string16 line;
+    for (std::vector<string16>::iterator w = words.begin(); w != words.end();
+        ++w) {
+      string16 word = *w;
+      if (w + 1 != words.end())
+        word.push_back(' ');
+      int word_width = font.GetStringWidth(word);
+      if (current_width + word_width > available_width) {
+        // Current width will exceed the available width. Must start a new line.
+        if (!line.empty())
+          result_lines.push_back(line);
+        current_width = 0;
+        line.clear();
+      }
+      current_width += word_width;
+      line.append(word);
+    }
+    result_lines.push_back(line);
+  }
+
+  // Clamp number of lines to |kMaxLines|.
+  if (result_lines.size() > kMaxLines) {
+    result_lines.resize(kMaxLines);
+    // Add ellipses character to last line.
+    result_lines[kMaxLines - 1] = ui::TruncateString(
+        result_lines.back(), result_lines.back().length() - 1);
+  }
+  *line_count = result_lines.size();
+
+  // Flatten the result.
+  string16 result;
+  for (std::vector<string16>::iterator l = result_lines.begin();
+      l != result_lines.end(); ++l) {
+    if (!result.empty())
+      result.push_back('\n');
+    int line_width = font.GetStringWidth(*l);
+    // Since we only break at word boundaries, it could happen that due to some
+    // very long word, line_width is greater than the available_width. In such
+    // case, we simply truncate at available_width and add ellipses at the end.
+    if (line_width > available_width) {
+      *max_width = available_width;
+      result.append(ui::ElideText(*l, font, available_width, ui::ELIDE_AT_END));
+    } else {
+      *max_width = std::max(*max_width, line_width);
+      result.append(*l);
+    }
+  }
+  *text = result;
+}
+
 void TooltipController::TooltipTimerFired() {
   UpdateIfRequired();
 }
 
 void TooltipController::UpdateIfRequired() {
   if (!tooltips_enabled_ || mouse_pressed_ || IsDragDropInProgress()) {
     tooltip_->Hide();
     return;
   }
 
@@ skipping 38 matching lines @@
 bool TooltipController::IsDragDropInProgress() {
   aura::client::DragDropClient* client = aura::client::GetDragDropClient(
       Shell::GetRootWindow());
   if (client)
     return client->IsDragDropInProgress();
   return false;
 }
 
 }  // namespace internal
 }  // namespace ash