ui/views/widget/tooltip_manager_win.cc

   1 // Copyright (c) 2012 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/widget/tooltip_manager_win.h"
   6
   7 #include <windowsx.h>
   8
   9 #include <limits>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/i18n/rtl.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/strings/string_split.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/win/scoped_hdc.h"
  19 #include "base/win/scoped_select_object.h"
  20 #include "ui/base/l10n/l10n_util_win.h"
  21 #include "ui/gfx/font_list.h"
  22 #include "ui/gfx/screen.h"
  23 #include "ui/gfx/text_elider.h"
  24 #include "ui/gfx/text_utils.h"
  25 #include "ui/gfx/win/dpi.h"
  26 #include "ui/gfx/win/hwnd_util.h"
  27 #include "ui/gfx/win/scoped_set_map_mode.h"
  28 #include "ui/views/view.h"
  29 #include "ui/views/widget/monitor_win.h"
  30 #include "ui/views/widget/widget.h"
  31
  32 namespace views {
  33
  34 namespace {
  35
  36 static int tooltip_height_ = 0;
  37
  38 // Maximum number of lines we allow in the tooltip.
  39 const size_t kMaxLines = 6;
  40
  41 // Trims the tooltip to fit, setting |text| to the clipped result, |max_width|
  42 // to the width (in pixels) of the clipped text and |line_count| to the number
  43 // of lines of text in the tooltip. |available_width| gives the space available
  44 // for the tooltip.
  45 void TrimTooltipToFit(const gfx::FontList& font_list,
  46                       int available_width,
  47                       base::string16* text,
  48                       int* max_width,
  49                       int* line_count) {
  50   *max_width = 0;
  51   *line_count = 0;
  52
  53   TooltipManager::TrimTooltipText(text);
  54
  55   // Split the string into at most kMaxLines lines.
  56   std::vector<base::string16> lines;
  57   base::SplitString(*text, '\n', &lines);
  58   if (lines.size() > kMaxLines)
  59     lines.resize(kMaxLines);
  60   *line_count = static_cast<int>(lines.size());
  61
  62   // Format each line to fit.
  63   base::string16 result;
  64   for (std::vector<base::string16>::iterator i = lines.begin();
  65        i != lines.end(); ++i) {
  66     base::string16 elided_text =
  67         gfx::ElideText(*i, font_list, available_width, gfx::ELIDE_AT_END);
  68     *max_width = std::max(*max_width,
  69                           gfx::GetStringWidth(elided_text, font_list));
  70     if (!result.empty())
  71       result.push_back('\n');
  72     result.append(elided_text);
  73   }
  74   *text = result;
  75 }
  76
  77 }  // namespace
  78
  79 // static
  80 int TooltipManager::GetTooltipHeight() {
  81   DCHECK_GT(tooltip_height_, 0);
  82   return tooltip_height_;
  83 }
  84
  85 static gfx::Font DetermineDefaultFont() {
  86   HWND window = CreateWindowEx(
  87       WS_EX_TRANSPARENT | l10n_util::GetExtendedTooltipStyles(),
  88       TOOLTIPS_CLASS, NULL, 0 , 0, 0, 0, 0, NULL, NULL, NULL, NULL);
  89   if (!window)
  90     return gfx::Font();
  91   HFONT hfont = reinterpret_cast<HFONT>(SendMessage(window, WM_GETFONT, 0, 0));
  92   gfx::Font font = hfont ? gfx::Font(hfont) : gfx::Font();
  93   DestroyWindow(window);
  94   return font;
  95 }
  96
  97 TooltipManagerWin::TooltipManagerWin(Widget* widget)
  98     : widget_(widget),
  99       tooltip_hwnd_(NULL),
 100       last_mouse_pos_(-1, -1),
 101       tooltip_showing_(false),
 102       last_tooltip_view_(NULL),
 103       last_view_out_of_sync_(false),
 104       tooltip_width_(0) {
 105   DCHECK(widget);
 106   DCHECK(widget->GetNativeView());
 107 }
 108
 109 TooltipManagerWin::~TooltipManagerWin() {
 110   if (tooltip_hwnd_)
 111     DestroyWindow(tooltip_hwnd_);
 112 }
 113
 114 bool TooltipManagerWin::Init() {
 115   DCHECK(!tooltip_hwnd_);
 116   // Create the tooltip control.
 117   tooltip_hwnd_ = CreateWindowEx(
 118       WS_EX_TRANSPARENT | l10n_util::GetExtendedTooltipStyles(),
 119       TOOLTIPS_CLASS, NULL, TTS_NOPREFIX, 0, 0, 0, 0,
 120       GetParent(), NULL, NULL, NULL);
 121   if (!tooltip_hwnd_)
 122     return false;
 123
 124   l10n_util::AdjustUIFontForWindow(tooltip_hwnd_);
 125
 126   // This effectively turns off clipping of tooltips. We need this otherwise
 127   // multi-line text (\r\n) won't work right. The size doesn't really matter
 128   // (just as long as its bigger than the monitor's width) as we clip to the
 129   // screen size before rendering.
 130   SendMessage(tooltip_hwnd_, TTM_SETMAXTIPWIDTH, 0,
 131               std::numeric_limits<int16>::max());
 132
 133   // Add one tool that is used for all tooltips.
 134   toolinfo_.cbSize = sizeof(toolinfo_);
 135   toolinfo_.uFlags = TTF_TRANSPARENT | TTF_IDISHWND;
 136   toolinfo_.hwnd = GetParent();
 137   toolinfo_.uId = reinterpret_cast<UINT_PTR>(GetParent());
 138   // Setting this tells windows to call GetParent() back (using a WM_NOTIFY
 139   // message) for the actual tooltip contents.
 140   toolinfo_.lpszText = LPSTR_TEXTCALLBACK;
 141   toolinfo_.lpReserved = NULL;
 142   SetRectEmpty(&toolinfo_.rect);
 143   SendMessage(tooltip_hwnd_, TTM_ADDTOOL, 0, (LPARAM)&toolinfo_);
 144   return true;
 145 }
 146
 147 gfx::NativeView TooltipManagerWin::GetParent() {
 148   return widget_->GetNativeView();
 149 }
 150
 151 const gfx::FontList& TooltipManagerWin::GetFontList() const {
 152   static gfx::FontList* font_list = NULL;
 153   if (!font_list)
 154     font_list = new gfx::FontList(DetermineDefaultFont());
 155   return *font_list;
 156 }
 157
 158 void TooltipManagerWin::UpdateTooltip() {
 159   // Set last_view_out_of_sync_ to indicate the view is currently out of sync.
 160   // This doesn't update the view under the mouse immediately as it may cause
 161   // timing problems.
 162   last_view_out_of_sync_ = true;
 163   last_tooltip_view_ = NULL;
 164   // Hide the tooltip.
 165   SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
 166 }
 167
 168 void TooltipManagerWin::TooltipTextChanged(View* view) {
 169   if (view == last_tooltip_view_)
 170     UpdateTooltip(last_mouse_pos_);
 171 }
 172
 173 LRESULT TooltipManagerWin::OnNotify(int w_param,
 174                                     NMHDR* l_param,
 175                                     bool* handled) {
 176   *handled = false;
 177   if (l_param->hwndFrom != tooltip_hwnd_)
 178     return 0;
 179
 180   switch (l_param->code) {
 181     case TTN_GETDISPINFO: {
 182       if (last_view_out_of_sync_) {
 183         // View under the mouse is out of sync, determine it now.
 184         View* root_view = widget_->GetRootView();
 185         last_tooltip_view_ =
 186             root_view->GetTooltipHandlerForPoint(last_mouse_pos_);
 187         last_view_out_of_sync_ = false;
 188       }
 189       // Tooltip control is asking for the tooltip to display.
 190       NMTTDISPINFOW* tooltip_info =
 191           reinterpret_cast<NMTTDISPINFOW*>(l_param);
 192       // Initialize the string, if we have a valid tooltip the string will
 193       // get reset below.
 194       tooltip_info->szText[0] = TEXT('\0');
 195       tooltip_text_.clear();
 196       tooltip_info->lpszText = NULL;
 197       clipped_text_.clear();
 198       if (last_tooltip_view_ != NULL) {
 199         tooltip_text_.clear();
 200         // Mouse is over a View, ask the View for its tooltip.
 201         gfx::Point view_loc = last_mouse_pos_;
 202         View::ConvertPointToTarget(widget_->GetRootView(),
 203                                    last_tooltip_view_, &view_loc);
 204         if (last_tooltip_view_->GetTooltipText(view_loc, &tooltip_text_) &&
 205             !tooltip_text_.empty()) {
 206           // View has a valid tip, copy it into TOOLTIPINFO.
 207           clipped_text_ = tooltip_text_;
 208           gfx::Point screen_loc = last_mouse_pos_;
 209           View::ConvertPointToScreen(widget_->GetRootView(), &screen_loc);
 210           TrimTooltipToFit(
 211               GetFontList(),
 212               GetMaxWidth(screen_loc.x(), screen_loc.y(),
 213                           widget_->GetNativeView()),
 214               &clipped_text_, &tooltip_width_, &line_count_);
 215           // Adjust the clipped tooltip text for locale direction.
 216           base::i18n::AdjustStringForLocaleDirection(&clipped_text_);
 217           tooltip_info->lpszText = const_cast<WCHAR*>(clipped_text_.c_str());
 218         } else {
 219           tooltip_text_.clear();
 220         }
 221       }
 222       *handled = true;
 223       return 0;
 224     }
 225     case TTN_POP:
 226       tooltip_showing_ = false;
 227       *handled = true;
 228       return 0;
 229     case TTN_SHOW: {
 230       *handled = true;
 231       tooltip_showing_ = true;
 232       // The tooltip is about to show, allow the view to position it
 233       gfx::Point text_origin;
 234       if (tooltip_height_ == 0)
 235         tooltip_height_ = CalcTooltipHeight();
 236       gfx::Point view_loc = last_mouse_pos_;
 237       View::ConvertPointToTarget(widget_->GetRootView(),
 238                                  last_tooltip_view_, &view_loc);
 239       if (last_tooltip_view_->GetTooltipTextOrigin(view_loc, &text_origin) &&
 240           SetTooltipPosition(text_origin.x(), text_origin.y())) {
 241         // Return true, otherwise the rectangle we specified is ignored.
 242         return TRUE;
 243       }
 244       return 0;
 245     }
 246     default:
 247       // Fall through.
 248       break;
 249   }
 250   return 0;
 251 }
 252
 253 bool TooltipManagerWin::SetTooltipPosition(int text_x, int text_y) {
 254   // NOTE: this really only tests that the y location fits on screen, but that
 255   // is good enough for our usage.
 256
 257   // Calculate the bounds the tooltip will get.
 258   gfx::Point view_loc;
 259   View::ConvertPointToScreen(last_tooltip_view_, &view_loc);
 260   view_loc = gfx::win::DIPToScreenPoint(view_loc);
 261   RECT bounds = { view_loc.x() + text_x,
 262                   view_loc.y() + text_y,
 263                   view_loc.x() + text_x + tooltip_width_,
 264                   view_loc.y() + line_count_ * GetTooltipHeight() };
 265   SendMessage(tooltip_hwnd_, TTM_ADJUSTRECT, TRUE, (LPARAM)&bounds);
 266
 267   // Make sure the rectangle completely fits on the current monitor. If it
 268   // doesn't, return false so that windows positions the tooltip at the
 269   // default location.
 270   gfx::Rect monitor_bounds =
 271       views::GetMonitorBoundsForRect(gfx::Rect(bounds.left, bounds.right,
 272                                                   0, 0));
 273   if (!monitor_bounds.Contains(gfx::Rect(bounds))) {
 274     return false;
 275   }
 276
 277   ::SetWindowPos(tooltip_hwnd_, NULL, bounds.left, bounds.top, 0, 0,
 278                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
 279   return true;
 280 }
 281
 282 int TooltipManagerWin::CalcTooltipHeight() {
 283   // Ask the tooltip for its font.
 284   int height;
 285   HFONT hfont = reinterpret_cast<HFONT>(
 286       SendMessage(tooltip_hwnd_, WM_GETFONT, 0, 0));
 287   if (hfont != NULL) {
 288     base::win::ScopedGetDC dc(tooltip_hwnd_);
 289     base::win::ScopedSelectObject font(dc, hfont);
 290     gfx::ScopedSetMapMode mode(dc, MM_TEXT);
 291     TEXTMETRIC font_metrics;
 292     GetTextMetrics(dc, &font_metrics);
 293     height = font_metrics.tmHeight;
 294   } else {
 295     // Tooltip is using the system font. Use gfx::Font, which should pick
 296     // up the system font.
 297     height = gfx::Font().GetHeight();
 298   }
 299   // Get the margins from the tooltip
 300   RECT tooltip_margin;
 301   SendMessage(tooltip_hwnd_, TTM_GETMARGIN, 0, (LPARAM)&tooltip_margin);
 302   return height + tooltip_margin.top + tooltip_margin.bottom;
 303 }
 304
 305 void TooltipManagerWin::UpdateTooltip(const gfx::Point& mouse_pos) {
 306   View* root_view = widget_->GetRootView();
 307   View* view = root_view->GetTooltipHandlerForPoint(mouse_pos);
 308   if (view != last_tooltip_view_) {
 309     // NOTE: This *must* be sent regardless of the visibility of the tooltip.
 310     // It triggers Windows to ask for the tooltip again.
 311     SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
 312     last_tooltip_view_ = view;
 313   } else if (last_tooltip_view_ != NULL) {
 314     // Tooltip is showing, and mouse is over the same view. See if the tooltip
 315     // text has changed.
 316     gfx::Point view_point = mouse_pos;
 317     View::ConvertPointToTarget(root_view, last_tooltip_view_, &view_point);
 318     string16 new_tooltip_text;
 319     bool has_tooltip_text =
 320         last_tooltip_view_->GetTooltipText(view_point, &new_tooltip_text);
 321     if (!has_tooltip_text || (new_tooltip_text != tooltip_text_)) {
 322       // The text has changed, hide the popup.
 323       SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
 324       if (has_tooltip_text && !new_tooltip_text.empty() && tooltip_showing_) {
 325         // New text is valid, show the popup.
 326         SendMessage(tooltip_hwnd_, TTM_POPUP, 0, 0);
 327       }
 328     }
 329   }
 330 }
 331
 332 void TooltipManagerWin::OnMouse(UINT u_msg, WPARAM w_param, LPARAM l_param) {
 333   gfx::Point mouse_pos_in_pixels(l_param);
 334   gfx::Point mouse_pos = gfx::win::ScreenToDIPPoint(mouse_pos_in_pixels);
 335
 336   if (u_msg >= WM_NCMOUSEMOVE && u_msg <= WM_NCXBUTTONDBLCLK) {
 337     // NC message coordinates are in screen coordinates.
 338     POINT temp = mouse_pos_in_pixels.ToPOINT();
 339     ::MapWindowPoints(HWND_DESKTOP, GetParent(), &temp, 1);
 340     mouse_pos_in_pixels.SetPoint(temp.x, temp.y);
 341     mouse_pos = gfx::win::ScreenToDIPPoint(mouse_pos_in_pixels);
 342   }
 343
 344   if (u_msg != WM_MOUSEMOVE || last_mouse_pos_ != mouse_pos) {
 345     last_mouse_pos_ = mouse_pos;
 346     UpdateTooltip(mouse_pos);
 347   }
 348   // Forward the message onto the tooltip.
 349   MSG msg;
 350   msg.hwnd = GetParent();
 351   msg.message = u_msg;
 352   msg.wParam = w_param;
 353   msg.lParam = l_param;
 354   SendMessage(tooltip_hwnd_, TTM_RELAYEVENT, 0, (LPARAM)&msg);
 355 }
 356
 357 }  // namespace views