ui/views/controls/label.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/controls/label.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <limits>
  10 #include <vector>
  11
  12 #include "base/i18n/rtl.h"
  13 #include "base/logging.h"
  14 #include "base/strings/string_split.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "ui/accessibility/ax_view_state.h"
  18 #include "ui/base/resource/resource_bundle.h"
  19 #include "ui/gfx/canvas.h"
  20 #include "ui/gfx/color_utils.h"
  21 #include "ui/gfx/insets.h"
  22 #include "ui/gfx/text_elider.h"
  23 #include "ui/gfx/text_utils.h"
  24 #include "ui/gfx/utf16_indexing.h"
  25 #include "ui/native_theme/native_theme.h"
  26 #include "ui/views/background.h"
  27
  28 namespace {
  29
  30 const int kCachedSizeLimit = 10;
  31 const base::char16 kPasswordReplacementChar = '*';
  32
  33 }  // namespace
  34
  35 namespace views {
  36
  37 // static
  38 const char Label::kViewClassName[] = "Label";
  39 const int Label::kFocusBorderPadding = 1;
  40
  41 Label::Label() {
  42   Init(base::string16(), gfx::FontList());
  43 }
  44
  45 Label::Label(const base::string16& text) {
  46   Init(text, gfx::FontList());
  47 }
  48
  49 Label::Label(const base::string16& text, const gfx::FontList& font_list) {
  50   Init(text, font_list);
  51 }
  52
  53 Label::~Label() {
  54 }
  55
  56 void Label::SetFontList(const gfx::FontList& font_list) {
  57   font_list_ = font_list;
  58   ResetCachedSize();
  59   PreferredSizeChanged();
  60   SchedulePaint();
  61 }
  62
  63 void Label::SetText(const base::string16& text) {
  64   if (text != text_)
  65     SetTextInternal(text);
  66 }
  67
  68 void Label::SetTextInternal(const base::string16& text) {
  69   text_ = text;
  70
  71   if (is_obscured_) {
  72     size_t obscured_text_length =
  73         static_cast<size_t>(gfx::UTF16IndexToOffset(text_, 0, text_.length()));
  74     layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
  75   } else {
  76     layout_text_ = text_;
  77   }
  78
  79   ResetCachedSize();
  80   PreferredSizeChanged();
  81   SchedulePaint();
  82 }
  83
  84 void Label::SetAutoColorReadabilityEnabled(bool enabled) {
  85   auto_color_readability_ = enabled;
  86   RecalculateColors();
  87 }
  88
  89 void Label::SetEnabledColor(SkColor color) {
  90   requested_enabled_color_ = color;
  91   enabled_color_set_ = true;
  92   RecalculateColors();
  93 }
  94
  95 void Label::SetDisabledColor(SkColor color) {
  96   requested_disabled_color_ = color;
  97   disabled_color_set_ = true;
  98   RecalculateColors();
  99 }
 100
 101 void Label::SetBackgroundColor(SkColor color) {
 102   background_color_ = color;
 103   background_color_set_ = true;
 104   RecalculateColors();
 105 }
 106
 107 void Label::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
 108   // If the UI layout is right-to-left, flip the alignment direction.
 109   if (base::i18n::IsRTL() &&
 110       (alignment == gfx::ALIGN_LEFT || alignment == gfx::ALIGN_RIGHT)) {
 111     alignment = (alignment == gfx::ALIGN_LEFT) ?
 112         gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
 113   }
 114   if (horizontal_alignment_ != alignment) {
 115     horizontal_alignment_ = alignment;
 116     SchedulePaint();
 117   }
 118 }
 119
 120 gfx::HorizontalAlignment Label::GetHorizontalAlignment() const {
 121   if (horizontal_alignment_ != gfx::ALIGN_TO_HEAD)
 122     return horizontal_alignment_;
 123
 124   const base::i18n::TextDirection dir =
 125       base::i18n::GetFirstStrongCharacterDirection(layout_text());
 126   return dir == base::i18n::RIGHT_TO_LEFT ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
 127 }
 128
 129 void Label::SetLineHeight(int height) {
 130   if (height != line_height_) {
 131     line_height_ = height;
 132     ResetCachedSize();
 133     PreferredSizeChanged();
 134     SchedulePaint();
 135   }
 136 }
 137
 138 void Label::SetMultiLine(bool multi_line) {
 139   DCHECK(!multi_line || (elide_behavior_ == gfx::ELIDE_TAIL ||
 140                          elide_behavior_ == gfx::NO_ELIDE));
 141   if (multi_line != is_multi_line_) {
 142     is_multi_line_ = multi_line;
 143     ResetCachedSize();
 144     PreferredSizeChanged();
 145     SchedulePaint();
 146   }
 147 }
 148
 149 void Label::SetObscured(bool obscured) {
 150   if (obscured != is_obscured_) {
 151     is_obscured_ = obscured;
 152     SetTextInternal(text_);
 153   }
 154 }
 155
 156 void Label::SetAllowCharacterBreak(bool allow_character_break) {
 157   if (allow_character_break != allow_character_break_) {
 158     allow_character_break_ = allow_character_break;
 159     ResetCachedSize();
 160     PreferredSizeChanged();
 161     SchedulePaint();
 162   }
 163 }
 164
 165 void Label::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
 166   DCHECK(!is_multi_line_ || (elide_behavior_ == gfx::ELIDE_TAIL ||
 167                              elide_behavior_ == gfx::NO_ELIDE));
 168   if (elide_behavior != elide_behavior_) {
 169     elide_behavior_ = elide_behavior;
 170     ResetCachedSize();
 171     PreferredSizeChanged();
 172     SchedulePaint();
 173   }
 174 }
 175
 176 void Label::SetTooltipText(const base::string16& tooltip_text) {
 177   tooltip_text_ = tooltip_text;
 178 }
 179
 180 void Label::SizeToFit(int max_width) {
 181   DCHECK(is_multi_line_);
 182
 183   std::vector<base::string16> lines;
 184   base::SplitString(layout_text(), '\n', &lines);
 185
 186   int label_width = 0;
 187   for (std::vector<base::string16>::const_iterator iter = lines.begin();
 188        iter != lines.end(); ++iter) {
 189     label_width = std::max(label_width, gfx::GetStringWidth(*iter, font_list_));
 190   }
 191
 192   label_width += GetInsets().width();
 193
 194   if (max_width > 0)
 195     label_width = std::min(label_width, max_width);
 196
 197   SetBounds(x(), y(), label_width, 0);
 198   SizeToPreferredSize();
 199 }
 200
 201 gfx::Insets Label::GetInsets() const {
 202   gfx::Insets insets = View::GetInsets();
 203   if (focusable()) {
 204     insets += gfx::Insets(kFocusBorderPadding, kFocusBorderPadding,
 205                           kFocusBorderPadding, kFocusBorderPadding);
 206   }
 207   return insets;
 208 }
 209
 210 int Label::GetBaseline() const {
 211   return GetInsets().top() + font_list_.GetBaseline();
 212 }
 213
 214 gfx::Size Label::GetPreferredSize() const {
 215   // Return a size of (0, 0) if the label is not visible and if the
 216   // collapse_when_hidden_ flag is set.
 217   // TODO(munjal): This logic probably belongs to the View class. But for now,
 218   // put it here since putting it in View class means all inheriting classes
 219   // need ot respect the collapse_when_hidden_ flag.
 220   if (!visible() && collapse_when_hidden_)
 221     return gfx::Size();
 222
 223   gfx::Size size(GetTextSize());
 224   gfx::Insets insets = GetInsets();
 225   size.Enlarge(insets.width(), insets.height());
 226   return size;
 227 }
 228
 229 gfx::Size Label::GetMinimumSize() const {
 230   gfx::Size text_size(GetTextSize());
 231   if ((!visible() && collapse_when_hidden_) || text_size.IsEmpty())
 232     return gfx::Size();
 233
 234   gfx::Size size(gfx::GetStringWidth(base::string16(gfx::kEllipsisUTF16),
 235                                      font_list_),
 236                  font_list_.GetHeight());
 237   size.SetToMin(text_size);  // The actual text may be shorter than an ellipsis.
 238   gfx::Insets insets = GetInsets();
 239   size.Enlarge(insets.width(), insets.height());
 240   return size;
 241 }
 242
 243 int Label::GetHeightForWidth(int w) const {
 244   if (!is_multi_line_)
 245     return View::GetHeightForWidth(w);
 246
 247   w = std::max(0, w - GetInsets().width());
 248
 249   for (size_t i = 0; i < cached_heights_.size(); ++i) {
 250     const gfx::Size& s = cached_heights_[i];
 251     if (s.width() == w)
 252       return s.height() + GetInsets().height();
 253   }
 254
 255   int cache_width = w;
 256
 257   int h = font_list_.GetHeight();
 258   const int flags = ComputeDrawStringFlags();
 259   gfx::Canvas::SizeStringInt(
 260       layout_text(), font_list_, &w, &h, line_height_, flags);
 261   cached_heights_[cached_heights_cursor_] = gfx::Size(cache_width, h);
 262   cached_heights_cursor_ = (cached_heights_cursor_ + 1) % kCachedSizeLimit;
 263   return h + GetInsets().height();
 264 }
 265
 266 const char* Label::GetClassName() const {
 267   return kViewClassName;
 268 }
 269
 270 View* Label::GetTooltipHandlerForPoint(const gfx::Point& point) {
 271   // Bail out if the label does not contain the point.
 272   // Note that HitTestPoint() cannot be used here as it uses
 273   // Label::HitTestRect() to determine if the point hits the label; and
 274   // Label::HitTestRect() always fails. Instead, default HitTestRect()
 275   // implementation should be used.
 276   if (!View::HitTestRect(gfx::Rect(point, gfx::Size(1, 1))))
 277     return NULL;
 278
 279   if (tooltip_text_.empty() && !ShouldShowDefaultTooltip())
 280     return NULL;
 281
 282   return this;
 283 }
 284
 285 bool Label::CanProcessEventsWithinSubtree() const {
 286   // Send events to the parent view for handling.
 287   return false;
 288 }
 289
 290 bool Label::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
 291   DCHECK(tooltip);
 292
 293   // If a tooltip has been explicitly set, use it.
 294   if (!tooltip_text_.empty()) {
 295     tooltip->assign(tooltip_text_);
 296     return true;
 297   }
 298
 299   // Show the full text if the text does not fit.
 300   if (ShouldShowDefaultTooltip()) {
 301     *tooltip = layout_text();
 302     return true;
 303   }
 304
 305   return false;
 306 }
 307
 308 void Label::GetAccessibleState(ui::AXViewState* state) {
 309   state->role = ui::AX_ROLE_STATIC_TEXT;
 310   state->AddStateFlag(ui::AX_STATE_READ_ONLY);
 311   state->name = layout_text();
 312 }
 313
 314 void Label::PaintText(gfx::Canvas* canvas,
 315                       const base::string16& text,
 316                       const gfx::Rect& text_bounds,
 317                       int flags) {
 318   SkColor color = enabled() ? actual_enabled_color_ : actual_disabled_color_;
 319   if (elide_behavior_ == gfx::FADE_TAIL) {
 320     canvas->DrawFadedString(text, font_list_, color, text_bounds, flags);
 321   } else {
 322     canvas->DrawStringRectWithShadows(text, font_list_, color, text_bounds,
 323                                       line_height_, flags, shadows_);
 324   }
 325
 326   if (HasFocus()) {
 327     gfx::Rect focus_bounds = text_bounds;
 328     focus_bounds.Inset(-kFocusBorderPadding, -kFocusBorderPadding);
 329     canvas->DrawFocusRect(focus_bounds);
 330   }
 331 }
 332
 333 gfx::Size Label::GetTextSize() const {
 334   if (!text_size_valid_) {
 335     // For single-line strings, we supply the largest possible width, because
 336     // while adding NO_ELLIPSIS to the flags works on Windows for forcing
 337     // SizeStringInt() to calculate the desired width, it doesn't seem to work
 338     // on Linux.
 339     int w = is_multi_line_ ?
 340         GetAvailableRect().width() : std::numeric_limits<int>::max();
 341     int h = font_list_.GetHeight();
 342     // For single-line strings, ignore the available width and calculate how
 343     // wide the text wants to be.
 344     int flags = ComputeDrawStringFlags();
 345     if (!is_multi_line_)
 346       flags |= gfx::Canvas::NO_ELLIPSIS;
 347     gfx::Canvas::SizeStringInt(
 348         layout_text(), font_list_, &w, &h, line_height_, flags);
 349     text_size_.SetSize(w, h);
 350     const gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(shadows_);
 351     text_size_.Enlarge(shadow_margin.width(), shadow_margin.height());
 352     text_size_valid_ = true;
 353   }
 354
 355   return text_size_;
 356 }
 357
 358 void Label::OnBoundsChanged(const gfx::Rect& previous_bounds) {
 359   text_size_valid_ &= !is_multi_line_;
 360 }
 361
 362 void Label::OnPaint(gfx::Canvas* canvas) {
 363   OnPaintBackground(canvas);
 364   // We skip painting the focus border because it is being handled seperately by
 365   // some subclasses of Label. We do not want View's focus border painting to
 366   // interfere with that.
 367   OnPaintBorder(canvas);
 368
 369   base::string16 paint_text;
 370   gfx::Rect text_bounds;
 371   int flags = 0;
 372   CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
 373   PaintText(canvas, paint_text, text_bounds, flags);
 374 }
 375
 376 void Label::OnNativeThemeChanged(const ui::NativeTheme* theme) {
 377   UpdateColorsFromTheme(theme);
 378 }
 379
 380 void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
 381   font_list_ = font_list;
 382   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
 383   subpixel_rendering_enabled_ = true;
 384   auto_color_readability_ = true;
 385   UpdateColorsFromTheme(ui::NativeTheme::instance());
 386   horizontal_alignment_ = gfx::ALIGN_CENTER;
 387   line_height_ = 0;
 388   is_multi_line_ = false;
 389   is_obscured_ = false;
 390   allow_character_break_ = false;
 391   elide_behavior_ = gfx::ELIDE_TAIL;
 392   collapse_when_hidden_ = false;
 393   directionality_mode_ = gfx::DIRECTIONALITY_FROM_UI;
 394   cached_heights_.resize(kCachedSizeLimit);
 395   ResetCachedSize();
 396
 397   SetText(text);
 398 }
 399
 400 void Label::RecalculateColors() {
 401   actual_enabled_color_ = auto_color_readability_ ?
 402       color_utils::GetReadableColor(requested_enabled_color_,
 403                                     background_color_) :
 404       requested_enabled_color_;
 405   actual_disabled_color_ = auto_color_readability_ ?
 406       color_utils::GetReadableColor(requested_disabled_color_,
 407                                     background_color_) :
 408       requested_disabled_color_;
 409 }
 410
 411 gfx::Rect Label::GetTextBounds() const {
 412   gfx::Rect available(GetAvailableRect());
 413   gfx::Size text_size(GetTextSize());
 414   text_size.set_width(std::min(available.width(), text_size.width()));
 415   gfx::Point origin(GetInsets().left(), GetInsets().top());
 416   switch (GetHorizontalAlignment()) {
 417     case gfx::ALIGN_LEFT:
 418       break;
 419     case gfx::ALIGN_CENTER:
 420       // Put any extra margin pixel on the left to match the legacy behavior
 421       // from the use of GetTextExtentPoint32() on Windows.
 422       origin.Offset((available.width() + 1 - text_size.width()) / 2, 0);
 423       break;
 424     case gfx::ALIGN_RIGHT:
 425       origin.set_x(available.right() - text_size.width());
 426       break;
 427     default:
 428       NOTREACHED();
 429       break;
 430   }
 431   origin.Offset(0, std::max(0, (available.height() - text_size.height())) / 2);
 432   return gfx::Rect(origin, text_size);
 433 }
 434
 435 int Label::ComputeDrawStringFlags() const {
 436   int flags = 0;
 437
 438   // We can't use subpixel rendering if the background is non-opaque.
 439   if (SkColorGetA(background_color_) != 0xFF || !subpixel_rendering_enabled_)
 440     flags |= gfx::Canvas::NO_SUBPIXEL_RENDERING;
 441
 442   if (directionality_mode_ == gfx::DIRECTIONALITY_FORCE_LTR) {
 443     flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 444   } else if (directionality_mode_ == gfx::DIRECTIONALITY_FORCE_RTL) {
 445     flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
 446   } else if (directionality_mode_ == gfx::DIRECTIONALITY_FROM_TEXT) {
 447     base::i18n::TextDirection direction =
 448         base::i18n::GetFirstStrongCharacterDirection(layout_text());
 449     if (direction == base::i18n::RIGHT_TO_LEFT)
 450       flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
 451     else
 452       flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
 453   }
 454
 455   switch (GetHorizontalAlignment()) {
 456     case gfx::ALIGN_LEFT:
 457       flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 458       break;
 459     case gfx::ALIGN_CENTER:
 460       flags |= gfx::Canvas::TEXT_ALIGN_CENTER;
 461       break;
 462     case gfx::ALIGN_RIGHT:
 463       flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
 464       break;
 465     default:
 466       NOTREACHED();
 467       break;
 468   }
 469
 470   if (!is_multi_line_)
 471     return flags;
 472
 473   flags |= gfx::Canvas::MULTI_LINE;
 474 #if !defined(OS_WIN)
 475     // Don't elide multiline labels on Linux.
 476     // Todo(davemoore): Do we depend on eliding multiline text?
 477     // Pango insists on limiting the number of lines to one if text is
 478     // elided. You can get around this if you can pass a maximum height
 479     // but we don't currently have that data when we call the pango code.
 480     flags |= gfx::Canvas::NO_ELLIPSIS;
 481 #endif
 482   if (allow_character_break_)
 483     flags |= gfx::Canvas::CHARACTER_BREAK;
 484
 485   return flags;
 486 }
 487
 488 gfx::Rect Label::GetAvailableRect() const {
 489   gfx::Rect bounds(size());
 490   bounds.Inset(GetInsets());
 491   return bounds;
 492 }
 493
 494 void Label::CalculateDrawStringParams(base::string16* paint_text,
 495                                       gfx::Rect* text_bounds,
 496                                       int* flags) const {
 497   DCHECK(paint_text && text_bounds && flags);
 498
 499   const bool forbid_ellipsis = elide_behavior_ == gfx::NO_ELIDE ||
 500                                elide_behavior_ == gfx::FADE_TAIL;
 501   if (is_multi_line_ || forbid_ellipsis) {
 502     *paint_text = layout_text();
 503   } else {
 504     *paint_text = gfx::ElideText(layout_text(), font_list_,
 505                                  GetAvailableRect().width(), elide_behavior_);
 506   }
 507
 508   *text_bounds = GetTextBounds();
 509   *flags = ComputeDrawStringFlags();
 510   // TODO(msw): Elide multi-line text with ElideRectangleText instead.
 511   if (!is_multi_line_ || forbid_ellipsis)
 512     *flags |= gfx::Canvas::NO_ELLIPSIS;
 513 }
 514
 515 void Label::UpdateColorsFromTheme(const ui::NativeTheme* theme) {
 516   if (!enabled_color_set_) {
 517     requested_enabled_color_ = theme->GetSystemColor(
 518         ui::NativeTheme::kColorId_LabelEnabledColor);
 519   }
 520   if (!disabled_color_set_) {
 521     requested_disabled_color_ = theme->GetSystemColor(
 522         ui::NativeTheme::kColorId_LabelDisabledColor);
 523   }
 524   if (!background_color_set_) {
 525     background_color_ = theme->GetSystemColor(
 526         ui::NativeTheme::kColorId_LabelBackgroundColor);
 527   }
 528   RecalculateColors();
 529 }
 530
 531 void Label::ResetCachedSize() {
 532   text_size_valid_ = false;
 533   cached_heights_cursor_ = 0;
 534   for (int i = 0; i < kCachedSizeLimit; ++i)
 535     cached_heights_[i] = gfx::Size();
 536 }
 537
 538 bool Label::ShouldShowDefaultTooltip() const {
 539   return !is_multi_line_ && !is_obscured_ &&
 540          gfx::GetStringWidth(layout_text(), font_list_) >
 541              GetAvailableRect().width();
 542 }
 543
 544 }  // namespace views