ui/views/controls/styled_label.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/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     : listener_(listener),
  98       displayed_on_background_color_set_(false),
  99       auto_color_readability_enabled_(true) {
 100   base::TrimWhitespace(text, base::TRIM_TRAILING, &text_);
 101 }
 102
 103 StyledLabel::~StyledLabel() {}
 104
 105 void StyledLabel::SetText(const base::string16& text) {
 106   text_ = text;
 107   style_ranges_.clear();
 108   RemoveAllChildViews(true);
 109   PreferredSizeChanged();
 110 }
 111
 112 void StyledLabel::SetBaseFontList(const gfx::FontList& font_list) {
 113   font_list_ = font_list;
 114   PreferredSizeChanged();
 115 }
 116
 117 void StyledLabel::AddStyleRange(const gfx::Range& range,
 118                                 const RangeStyleInfo& style_info) {
 119   DCHECK(!range.is_reversed());
 120   DCHECK(!range.is_empty());
 121   DCHECK(gfx::Range(0, text_.size()).Contains(range));
 122
 123   // Insert the new range in sorted order.
 124   StyleRanges new_range;
 125   new_range.push_front(StyleRange(range, style_info));
 126   style_ranges_.merge(new_range);
 127
 128   PreferredSizeChanged();
 129 }
 130
 131 void StyledLabel::SetDefaultStyle(const RangeStyleInfo& style_info) {
 132   default_style_info_ = style_info;
 133   PreferredSizeChanged();
 134 }
 135
 136 void StyledLabel::SetDisplayedOnBackgroundColor(SkColor color) {
 137   displayed_on_background_color_ = color;
 138   displayed_on_background_color_set_ = true;
 139 }
 140
 141 gfx::Insets StyledLabel::GetInsets() const {
 142   gfx::Insets insets = View::GetInsets();
 143
 144   // We need a focus border iff we contain a link that will have a focus border.
 145   // That in turn will be true only if the link is non-empty.
 146   for (StyleRanges::const_iterator i(style_ranges_.begin());
 147         i != style_ranges_.end(); ++i) {
 148     if (i->style_info.is_link && !i->range.is_empty()) {
 149       const gfx::Insets focus_border_padding(
 150           Label::kFocusBorderPadding, Label::kFocusBorderPadding,
 151           Label::kFocusBorderPadding, Label::kFocusBorderPadding);
 152       insets += focus_border_padding;
 153       break;
 154     }
 155   }
 156
 157   return insets;
 158 }
 159
 160 int StyledLabel::GetHeightForWidth(int w) const {
 161   if (w != calculated_size_.width()) {
 162     // TODO(erg): Munge the const-ness of the style label. CalculateAndDoLayout
 163     // doesn't actually make any changes to member variables when |dry_run| is
 164     // set to true. In general, the mutating and non-mutating parts shouldn't
 165     // be in the same codepath.
 166     calculated_size_ =
 167         const_cast<StyledLabel*>(this)->CalculateAndDoLayout(w, true);
 168   }
 169   return calculated_size_.height();
 170 }
 171
 172 void StyledLabel::Layout() {
 173   calculated_size_ = CalculateAndDoLayout(GetLocalBounds().width(), false);
 174 }
 175
 176 void StyledLabel::PreferredSizeChanged() {
 177   calculated_size_ = gfx::Size();
 178   View::PreferredSizeChanged();
 179 }
 180
 181 void StyledLabel::LinkClicked(Link* source, int event_flags) {
 182   if (listener_)
 183     listener_->StyledLabelLinkClicked(link_targets_[source], event_flags);
 184 }
 185
 186 gfx::Size StyledLabel::CalculateAndDoLayout(int width, bool dry_run) {
 187   if (!dry_run) {
 188     RemoveAllChildViews(true);
 189     link_targets_.clear();
 190   }
 191
 192   width -= GetInsets().width();
 193   if (width <= 0 || text_.empty())
 194     return gfx::Size();
 195
 196   const int line_height = CalculateLineHeight(font_list_);
 197   // The index of the line we're on.
 198   int line = 0;
 199   // The x position (in pixels) of the line we're on, relative to content
 200   // bounds.
 201   int x = 0;
 202
 203   base::string16 remaining_string = text_;
 204   StyleRanges::const_iterator current_range = style_ranges_.begin();
 205
 206   // Iterate over the text, creating a bunch of labels and links and laying them
 207   // out in the appropriate positions.
 208   while (!remaining_string.empty()) {
 209     // Don't put whitespace at beginning of a line with an exception for the
 210     // first line (so the text's leading whitespace is respected).
 211     if (x == 0 && line > 0) {
 212       base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
 213                            &remaining_string);
 214     }
 215
 216     gfx::Range range(gfx::Range::InvalidRange());
 217     if (current_range != style_ranges_.end())
 218       range = current_range->range;
 219
 220     const size_t position = text_.size() - remaining_string.size();
 221
 222     const gfx::Rect chunk_bounds(x, 0, width - x, 2 * line_height);
 223     std::vector<base::string16> substrings;
 224     gfx::FontList text_font_list = font_list_;
 225     // If the start of the remaining text is inside a styled range, the font
 226     // style may differ from the base font. The font specified by the range
 227     // should be used when eliding text.
 228     if (position >= range.start()) {
 229       text_font_list = text_font_list.DeriveWithStyle(
 230           current_range->style_info.font_style);
 231     }
 232     gfx::ElideRectangleText(remaining_string,
 233                             text_font_list,
 234                             chunk_bounds.width(),
 235                             chunk_bounds.height(),
 236                             gfx::IGNORE_LONG_WORDS,
 237                             &substrings);
 238
 239     DCHECK(!substrings.empty());
 240     base::string16 chunk = substrings[0];
 241     if (chunk.empty()) {
 242       // Nothing fits on this line. Start a new line.
 243       // If x is 0, first line may have leading whitespace that doesn't fit in a
 244       // single line, so try trimming those. Otherwise there is no room for
 245       // anything; abort.
 246       if (x == 0) {
 247         if (line == 0) {
 248           base::TrimWhitespace(remaining_string, base::TRIM_LEADING,
 249                                &remaining_string);
 250           continue;
 251         }
 252         break;
 253       }
 254
 255       x = 0;
 256       line++;
 257       continue;
 258     }
 259
 260     scoped_ptr<Label> label;
 261     if (position >= range.start()) {
 262       const RangeStyleInfo& style_info = current_range->style_info;
 263
 264       if (style_info.disable_line_wrapping && chunk.size() < range.length() &&
 265           position == range.start() && x != 0) {
 266         // If the chunk should not be wrapped, try to fit it entirely on the
 267         // next line.
 268         x = 0;
 269         line++;
 270         continue;
 271       }
 272
 273       chunk = chunk.substr(0, std::min(chunk.size(), range.end() - position));
 274
 275       label = CreateLabelRange(chunk, font_list_, style_info, this);
 276
 277       if (style_info.is_link && !dry_run)
 278         link_targets_[label.get()] = range;
 279
 280       if (position + chunk.size() >= range.end())
 281         ++current_range;
 282     } else {
 283       // This chunk is normal text.
 284       if (position + chunk.size() > range.start())
 285         chunk = chunk.substr(0, range.start() - position);
 286       label = CreateLabelRange(chunk, font_list_, default_style_info_, this);
 287     }
 288
 289     if (displayed_on_background_color_set_)
 290       label->SetBackgroundColor(displayed_on_background_color_);
 291     label->SetAutoColorReadabilityEnabled(auto_color_readability_enabled_);
 292
 293     // Calculate the size of the optional focus border, and overlap by that
 294     // amount. Otherwise, "<a>link</a>," will render as "link ,".
 295     gfx::Insets focus_border_insets(label->GetInsets());
 296     focus_border_insets += -label->View::GetInsets();
 297     const gfx::Size view_size = label->GetPreferredSize();
 298     DCHECK_EQ(line_height, view_size.height() - focus_border_insets.height());
 299     if (!dry_run) {
 300       label->SetBoundsRect(gfx::Rect(
 301           gfx::Point(GetInsets().left() + x - focus_border_insets.left(),
 302                      GetInsets().top() + line * line_height -
 303                          focus_border_insets.top()),
 304           view_size));
 305       AddChildView(label.release());
 306     }
 307     x += view_size.width() - focus_border_insets.width();
 308
 309     remaining_string = remaining_string.substr(chunk.size());
 310   }
 311
 312   return gfx::Size(width, (line + 1) * line_height + GetInsets().height());
 313 }
 314
 315 }  // namespace views