Home | History | Annotate | Download | only in controls 
      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/controls/styled_label.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/strings/string_util.h"
     10 #include "ui/gfx/font_list.h"
     11 #include "ui/gfx/text_elider.h"
     12 #include "ui/native_theme/native_theme.h"
     13 #include "ui/views/controls/label.h"
     14 #include "ui/views/controls/link.h"
     15 #include "ui/views/controls/styled_label_listener.h"
     16 
     17 namespace views {
     18 
     19 
     20 // Helpers --------------------------------------------------------------------
     21 
     22 namespace {
     23 
     24 // Calculates the height of a line of text. Currently returns the height of
     25 // a label.
     26 int CalculateLineHeight(const gfx::FontList& font_list) {
     27   Label label;
     28   label.SetFontList(font_list);
     29   return label.GetPreferredSize().height();
     30 }
     31 
     32 scoped_ptr<Label> CreateLabelRange(
     33     const base::string16& text,
     34     const gfx::FontList& font_list,
     35     const StyledLabel::RangeStyleInfo& style_info,
     36     views::LinkListener* link_listener) {
     37   scoped_ptr<Label> result;
     38 
     39   if (style_info.is_link) {
     40     Link* link = new Link(text);
     41     link->set_listener(link_listener);
     42     link->SetUnderline((style_info.font_style & gfx::Font::UNDERLINE) != 0);
     43     result.reset(link);
     44   } else {
     45     result.reset(new Label(text));
     46   }
     47 
     48   result->SetEnabledColor(style_info.color);
     49   result->SetFontList(font_list);
     50 
     51   if (!style_info.tooltip.empty())
     52     result->SetTooltipText(style_info.tooltip);
     53   if (style_info.font_style != gfx::Font::NORMAL) {
     54     result->SetFontList(
     55         result->font_list().DeriveWithStyle(style_info.font_style));
     56   }
     57 
     58   return result.Pass();
     59 }
     60 
     61 }  // namespace
     62 
     63 
     64 // StyledLabel::RangeStyleInfo ------------------------------------------------
     65 
     66 StyledLabel::RangeStyleInfo::RangeStyleInfo()
     67     : font_style(gfx::Font::NORMAL),
     68       color(ui::NativeTheme::instance()->GetSystemColor(
     69           ui::NativeTheme::kColorId_LabelEnabledColor)),
     70       disable_line_wrapping(false),
     71       is_link(false) {}
     72 
     73 StyledLabel::RangeStyleInfo::~RangeStyleInfo() {}
     74 
     75 // static
     76 StyledLabel::RangeStyleInfo StyledLabel::RangeStyleInfo::CreateForLink() {
     77   RangeStyleInfo result;
     78   result.disable_line_wrapping = true;
     79   result.is_link = true;
     80   result.color = Link::GetDefaultEnabledColor();
     81   return result;
     82 }
     83 
     84 
     85 // StyledLabel::StyleRange ----------------------------------------------------
     86 
     87 bool StyledLabel::StyleRange::operator<(
     88     const StyledLabel::StyleRange& other) const {
     89   return range.start() < other.range.start();
     90 }
     91 
     92 
     93 // StyledLabel ----------------------------------------------------------------
     94 
     95 StyledLabel::StyledLabel(const base::string16& text,
     96                          StyledLabelListener* listener)
     97     : specified_line_height_(0),
     98       listener_(listener),
     99       displayed_on_background_color_set_(false),
    100       auto_color_readability_enabled_(true) {
    101   base::TrimWhitespace(text, base::TRIM_TRAILING, &text_);
    102 }
    103 
    104 StyledLabel::~StyledLabel() {}
    105 
    106 void StyledLabel::SetText(const base::string16& text) {
    107   text_ = text;
    108   style_ranges_.clear();
    109   RemoveAllChildViews(true);
    110   PreferredSizeChanged();
    111 }
    112 
    113 void StyledLabel::SetBaseFontList(const gfx::FontList& font_list) {
    114   font_list_ = font_list;
    115   PreferredSizeChanged();
    116 }
    117 
    118 void StyledLabel::AddStyleRange(const gfx::Range& range,
    119                                 const RangeStyleInfo& style_info) {
    120   DCHECK(!range.is_reversed());
    121   DCHECK(!range.is_empty());
    122   DCHECK(gfx::Range(0, text_.size()).Contains(range));
    123 
    124   // Insert the new range in sorted order.
    125   StyleRanges new_range;
    126   new_range.push_front(StyleRange(range, style_info));
    127   style_ranges_.merge(new_range);
    128 
    129   PreferredSizeChanged();
    130 }
    131 
    132 void StyledLabel::SetDefaultStyle(const RangeStyleInfo& style_info) {
    133   default_style_info_ = style_info;
    134   PreferredSizeChanged();
    135 }
    136 
    137 void StyledLabel::SetLineHeight(int line_height) {
    138   specified_line_height_ = line_height;
    139   PreferredSizeChanged();
    140 }
    141 
    142 void StyledLabel::SetDisplayedOnBackgroundColor(SkColor color) {
    143   displayed_on_background_color_ = color;
    144   displayed_on_background_color_set_ = true;
    145 }
    146 
    147 gfx::Insets StyledLabel::GetInsets() const {
    148   gfx::Insets insets = View::GetInsets();
    149 
    150   // We need a focus border iff we contain a link that will have a focus border.
    151   // That in turn will be true only if the link is non-empty.
    152   for (StyleRanges::const_iterator i(style_ranges_.begin());
    153         i != style_ranges_.end(); ++i) {
    154     if (i->style_info.is_link && !i->range.is_empty()) {
    155       const gfx::Insets focus_border_padding(
    156           Label::kFocusBorderPadding, Label::kFocusBorderPadding,
    157           Label::kFocusBorderPadding, Label::kFocusBorderPadding);
    158       insets += focus_border_padding;
    159       break;
    160     }
    161   }
    162 
    163   return insets;
    164 }
    165 
    166 int StyledLabel::GetHeightForWidth(int w) const {
    167   if (w != calculated_size_.width()) {
    168     // TODO(erg): Munge the const-ness of the style label. CalculateAndDoLayout
    169     // doesn't actually make any changes to member variables when |dry_run| is
    170     // set to true. In general, the mutating and non-mutating parts shouldn't
    171     // be in the same codepath.
    172     calculated_size_ =
    173         const_cast<StyledLabel*>(this)->CalculateAndDoLayout(w, true);
    174   }
    175   return calculated_size_.height();
    176 }
    177 
    178 void StyledLabel::Layout() {
    179   calculated_size_ = CalculateAndDoLayout(GetLocalBounds().width(), false);
    180 }
    181 
    182 void StyledLabel::PreferredSizeChanged() {
    183   calculated_size_ = gfx::Size();
    184   View::PreferredSizeChanged();
    185 }
    186 
    187 void StyledLabel::LinkClicked(Link* source, int event_flags) {
    188   if (listener_)
    189     listener_->StyledLabelLinkClicked(link_targets_[source], event_flags);
    190 }
    191 
    192 gfx::Size StyledLabel::CalculateAndDoLayout(int width, bool dry_run) {
    193   if (!dry_run) {
    194     RemoveAllChildViews(true);
    195     link_targets_.clear();
    196   }
    197 
    198   width -= GetInsets().width();
    199   if (width <= 0 || text_.empty())
    200     return gfx::Size();
    201 
    202   const int line_height = specified_line_height_ > 0 ? specified_line_height_
    203       : CalculateLineHeight(font_list_);
    204   // The index of the line we're on.
    205   int line = 0;
    206   // The x position (in pixels) of the line we're on, relative to content
    207   // bounds.
    208   int x = 0;
    209 
    210   base::string16 remaining_string = text_;
    211   StyleRanges::const_iterator current_range = style_ranges_.begin();
    212 
    213   // Iterate over the text, creating a bunch of labels and links and laying them
    214   // out in the appropriate positions.
    215   while (!remaining_string.empty()) {
    216     // Don't put whitespace at beginning of a line with an exception for the
    217     // first line (so the text's leading whitespace is respected).
    218     if (x == 0 && line > 0) {
    219       base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
    220                            &remaining_string);
    221     }
    222 
    223     gfx::Range range(gfx::Range::InvalidRange());
    224     if (current_range != style_ranges_.end())
    225       range = current_range->range;
    226 
    227     const size_t position = text_.size() - remaining_string.size();
    228 
    229     const gfx::Rect chunk_bounds(x, 0, width - x, 2 * line_height);
    230     std::vector<base::string16> substrings;
    231     gfx::FontList text_font_list = font_list_;
    232     // If the start of the remaining text is inside a styled range, the font
    233     // style may differ from the base font. The font specified by the range
    234     // should be used when eliding text.
    235     if (position >= range.start()) {
    236       text_font_list = text_font_list.DeriveWithStyle(
    237           current_range->style_info.font_style);
    238     }
    239     gfx::ElideRectangleText(remaining_string,
    240                             text_font_list,
    241                             chunk_bounds.width(),
    242                             chunk_bounds.height(),
    243                             gfx::IGNORE_LONG_WORDS,
    244                             &substrings);
    245 
    246     DCHECK(!substrings.empty());
    247     base::string16 chunk = substrings[0];
    248     if (chunk.empty()) {
    249       // Nothing fits on this line. Start a new line.
    250       // If x is 0, first line may have leading whitespace that doesn't fit in a
    251       // single line, so try trimming those. Otherwise there is no room for
    252       // anything; abort.
    253       if (x == 0) {
    254         if (line == 0) {
    255           base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
    256                                &remaining_string);
    257           continue;
    258         }
    259         break;
    260       }
    261 
    262       x = 0;
    263       line++;
    264       continue;
    265     }
    266 
    267     scoped_ptr<Label> label;
    268     if (position >= range.start()) {
    269       const RangeStyleInfo& style_info = current_range->style_info;
    270 
    271       if (style_info.disable_line_wrapping && chunk.size() < range.length() &&
    272           position == range.start() && x != 0) {
    273         // If the chunk should not be wrapped, try to fit it entirely on the
    274         // next line.
    275         x = 0;
    276         line++;
    277         continue;
    278       }
    279 
    280       chunk = chunk.substr(0, std::min(chunk.size(), range.end() - position));
    281 
    282       label = CreateLabelRange(chunk, font_list_, style_info, this);
    283 
    284       if (style_info.is_link && !dry_run)
    285         link_targets_[label.get()] = range;
    286 
    287       if (position + chunk.size() >= range.end())
    288         ++current_range;
    289     } else {
    290       // This chunk is normal text.
    291       if (position + chunk.size() > range.start())
    292         chunk = chunk.substr(0, range.start() - position);
    293       label = CreateLabelRange(chunk, font_list_, default_style_info_, this);
    294     }
    295 
    296     if (displayed_on_background_color_set_)
    297       label->SetBackgroundColor(displayed_on_background_color_);
    298     label->SetAutoColorReadabilityEnabled(auto_color_readability_enabled_);
    299 
    300     // Calculate the size of the optional focus border, and overlap by that
    301     // amount. Otherwise, "<a>link</a>," will render as "link ,".
    302     gfx::Insets focus_border_insets(label->GetInsets());
    303     focus_border_insets += -label->View::GetInsets();
    304     const gfx::Size view_size = label->GetPreferredSize();
    305     if (!dry_run) {
    306       label->SetBoundsRect(gfx::Rect(
    307           gfx::Point(GetInsets().left() + x - focus_border_insets.left(),
    308                      GetInsets().top() + line * line_height -
    309                          focus_border_insets.top()),
    310           view_size));
    311       AddChildView(label.release());
    312     }
    313     x += view_size.width() - focus_border_insets.width();
    314 
    315     remaining_string = remaining_string.substr(chunk.size());
    316   }
    317 
    318   // The user-specified line height only applies to interline spacing, so the
    319   // final line's height is unaffected.
    320   int total_height = line * line_height +
    321       CalculateLineHeight(font_list_) + GetInsets().height();
    322   return gfx::Size(width, total_height);
    323 }
    324 
    325 }  // namespace views
    326