ui/views/corewm/tooltip_aura.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/corewm/tooltip_aura.h"
   6
   7 #include "base/strings/string_split.h"
   8 #include "ui/aura/window.h"
   9 #include "ui/aura/window_tree_host.h"
  10 #include "ui/gfx/screen.h"
  11 #include "ui/gfx/text_elider.h"
  12 #include "ui/gfx/text_utils.h"
  13 #include "ui/native_theme/native_theme.h"
  14 #include "ui/views/background.h"
  15 #include "ui/views/border.h"
  16 #include "ui/views/widget/widget.h"
  17
  18 namespace {
  19
  20 // Max visual tooltip width. If a tooltip is greater than this width, it will
  21 // be wrapped.
  22 const int kTooltipMaxWidthPixels = 400;
  23
  24 const size_t kMaxLines = 10;
  25
  26 // FIXME: get cursor offset from actual cursor size.
  27 const int kCursorOffsetX = 10;
  28 const int kCursorOffsetY = 15;
  29
  30 // Creates a widget of type TYPE_TOOLTIP
  31 views::Widget* CreateTooltipWidget(aura::Window* tooltip_window) {
  32   views::Widget* widget = new views::Widget;
  33   views::Widget::InitParams params;
  34   // For aura, since we set the type to TYPE_TOOLTIP, the widget will get
  35   // auto-parented to the right container.
  36   params.type = views::Widget::InitParams::TYPE_TOOLTIP;
  37   params.context = tooltip_window;
  38   DCHECK(params.context);
  39   params.keep_on_top = true;
  40   params.accept_events = false;
  41   widget->Init(params);
  42   return widget;
  43 }
  44
  45 }  // namespace
  46
  47 namespace views {
  48 namespace corewm {
  49
  50 TooltipAura::TooltipAura()
  51     : widget_(NULL),
  52       tooltip_window_(NULL) {
  53   label_.set_owned_by_client();
  54   label_.SetMultiLine(true);
  55   label_.SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
  56
  57   const int kHorizontalPadding = 3;
  58   const int kVerticalPadding = 2;
  59   label_.SetBorder(Border::CreateEmptyBorder(
  60       kVerticalPadding, kHorizontalPadding,
  61       kVerticalPadding, kHorizontalPadding));
  62 }
  63
  64 TooltipAura::~TooltipAura() {
  65   DestroyWidget();
  66 }
  67
  68 // static
  69 void TooltipAura::TrimTooltipToFit(const gfx::FontList& font_list,
  70                                    int max_width,
  71                                    base::string16* text,
  72                                    int* width,
  73                                    int* line_count) {
  74   *width = 0;
  75   *line_count = 0;
  76
  77   // Determine the available width for the tooltip.
  78   int available_width = std::min(kTooltipMaxWidthPixels, max_width);
  79
  80   std::vector<base::string16> lines;
  81   base::SplitString(*text, '\n', &lines);
  82   std::vector<base::string16> result_lines;
  83
  84   // Format each line to fit.
  85   for (std::vector<base::string16>::iterator l = lines.begin();
  86        l != lines.end(); ++l) {
  87     // We break the line at word boundaries, then stuff as many words as we can
  88     // in the available width to the current line, and move the remaining words
  89     // to a new line.
  90     std::vector<base::string16> words;
  91     base::SplitStringDontTrim(*l, ' ', &words);
  92     int current_width = 0;
  93     base::string16 line;
  94     for (std::vector<base::string16>::iterator w = words.begin();
  95          w != words.end(); ++w) {
  96       base::string16 word = *w;
  97       if (w + 1 != words.end())
  98         word.push_back(' ');
  99       int word_width = gfx::GetStringWidth(word, font_list);
 100       if (current_width + word_width > available_width) {
 101         // Current width will exceed the available width. Must start a new line.
 102         if (!line.empty())
 103           result_lines.push_back(line);
 104         current_width = 0;
 105         line.clear();
 106       }
 107       current_width += word_width;
 108       line.append(word);
 109     }
 110     result_lines.push_back(line);
 111   }
 112
 113   // Clamp number of lines to |kMaxLines|.
 114   if (result_lines.size() > kMaxLines) {
 115     result_lines.resize(kMaxLines);
 116     // Add ellipses character to last line.
 117     result_lines[kMaxLines - 1] = gfx::TruncateString(
 118         result_lines.back(), result_lines.back().length() - 1, gfx::WORD_BREAK);
 119   }
 120   *line_count = result_lines.size();
 121
 122   // Flatten the result.
 123   base::string16 result;
 124   for (std::vector<base::string16>::iterator l = result_lines.begin();
 125       l != result_lines.end(); ++l) {
 126     if (!result.empty())
 127       result.push_back('\n');
 128     int line_width = gfx::GetStringWidth(*l, font_list);
 129     // Since we only break at word boundaries, it could happen that due to some
 130     // very long word, line_width is greater than the available_width. In such
 131     // case, we simply truncate at available_width and add ellipses at the end.
 132     if (line_width > available_width) {
 133       *width = available_width;
 134       result.append(gfx::ElideText(*l, font_list, available_width,
 135                                    gfx::ELIDE_TAIL));
 136     } else {
 137       *width = std::max(*width, line_width);
 138       result.append(*l);
 139     }
 140   }
 141   *text = result;
 142 }
 143
 144 void TooltipAura::SetTooltipBounds(const gfx::Point& mouse_pos,
 145                                    const gfx::Size& tooltip_size) {
 146   gfx::Rect tooltip_rect(mouse_pos, tooltip_size);
 147   tooltip_rect.Offset(kCursorOffsetX, kCursorOffsetY);
 148   gfx::Screen* screen = gfx::Screen::GetScreenFor(tooltip_window_);
 149   gfx::Rect display_bounds(screen->GetDisplayNearestPoint(mouse_pos).bounds());
 150
 151   // If tooltip is out of bounds on the x axis, we simply shift it
 152   // horizontally by the offset.
 153   if (tooltip_rect.right() > display_bounds.right()) {
 154     int h_offset = tooltip_rect.right() - display_bounds.right();
 155     tooltip_rect.Offset(-h_offset, 0);
 156   }
 157
 158   // If tooltip is out of bounds on the y axis, we flip it to appear above the
 159   // mouse cursor instead of below.
 160   if (tooltip_rect.bottom() > display_bounds.bottom())
 161     tooltip_rect.set_y(mouse_pos.y() - tooltip_size.height());
 162
 163   tooltip_rect.AdjustToFit(display_bounds);
 164   widget_->SetBounds(tooltip_rect);
 165 }
 166
 167 void TooltipAura::DestroyWidget() {
 168   if (widget_) {
 169     widget_->RemoveObserver(this);
 170     widget_->Close();
 171     widget_ = NULL;
 172   }
 173 }
 174
 175 int TooltipAura::GetMaxWidth(const gfx::Point& location,
 176                              aura::Window* context) const {
 177   gfx::Screen* screen = gfx::Screen::GetScreenFor(context);
 178   gfx::Rect display_bounds(screen->GetDisplayNearestPoint(location).bounds());
 179   return std::min(kTooltipMaxWidthPixels, (display_bounds.width() + 1) / 2);
 180 }
 181
 182 void TooltipAura::SetText(aura::Window* window,
 183                           const base::string16& tooltip_text,
 184                           const gfx::Point& location) {
 185   tooltip_window_ = window;
 186   int max_width = 0;
 187   int line_count = 0;
 188   base::string16 trimmed_text(tooltip_text);
 189   TrimTooltipToFit(label_.font_list(), GetMaxWidth(location, window),
 190                    &trimmed_text, &max_width, &line_count);
 191   label_.SetText(trimmed_text);
 192
 193   if (!widget_) {
 194     widget_ = CreateTooltipWidget(tooltip_window_);
 195     widget_->SetContentsView(&label_);
 196     widget_->AddObserver(this);
 197   }
 198
 199   label_.SizeToFit(max_width + label_.GetInsets().width());
 200   SetTooltipBounds(location, label_.size());
 201
 202   ui::NativeTheme* native_theme = widget_->GetNativeTheme();
 203   label_.set_background(
 204       views::Background::CreateSolidBackground(
 205           native_theme->GetSystemColor(
 206               ui::NativeTheme::kColorId_TooltipBackground)));
 207
 208   label_.SetAutoColorReadabilityEnabled(false);
 209   label_.SetEnabledColor(native_theme->GetSystemColor(
 210       ui::NativeTheme::kColorId_TooltipText));
 211 }
 212
 213 void TooltipAura::Show() {
 214   if (widget_) {
 215     widget_->Show();
 216     widget_->StackAtTop();
 217   }
 218 }
 219
 220 void TooltipAura::Hide() {
 221   tooltip_window_ = NULL;
 222   if (widget_)
 223     widget_->Hide();
 224 }
 225
 226 bool TooltipAura::IsVisible() {
 227   return widget_ && widget_->IsVisible();
 228 }
 229
 230 void TooltipAura::OnWidgetDestroying(views::Widget* widget) {
 231   DCHECK_EQ(widget_, widget);
 232   widget_ = NULL;
 233   tooltip_window_ = NULL;
 234 }
 235
 236 }  // namespace corewm
 237 }  // namespace views