Home | History | Annotate | Download | only in controls 
      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::TRUNCATE));
    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::TRUNCATE));
    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::TRUNCATE ||
    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
    545