Add ability to defined ranges with different styles in StyledLabel

ui/views/controls/styled_label.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/controls/styled_label.h"
 
 #include <vector>
 
 #include "base/string_util.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/styled_label_listener.h"
 
 namespace views {
 
 namespace {
 
 // Calculates the height of a line of text. Currently returns the height of
 // a label.
 int CalculateLineHeight() {
   Label label;
   return label.GetPreferredSize().height();
 }
 
+scoped_ptr<View> CreateLabelRange(const string16& text,
+                                  const StyledLabel::RangeStyleInfo& style_info,
+                                  views::LinkListener* link_listener) {
+  scoped_ptr<Label> result;
+
+  if (style_info.linkify) {
+    Link* link = new Link(text);
+    link->set_listener(link_listener);
+    link->SetUnderline(style_info.font_style & gfx::Font::UNDERLINE);
+    result.reset(link);
+  } else {
+    Label* label = new Label(text);
+    // Give the label a focus border so that its preferred size matches
+    // links' preferred sizes
+    label->SetHasFocusBorder(true);
+
+    result.reset(label);
+  }
+
+  if (!style_info.tooltip.empty())
+    result->SetTooltipText(style_info.tooltip);
+  if (style_info.font_style != gfx::Font::NORMAL)
+    result->SetFont(result->font().DeriveFont(0, style_info.font_style));

[Evan Stade, 2013/03/18 23:20:50]

setting a different font means that the bounds calculated for the label with
ui::ElideRectangleText may be incorrect.

[tbarzic, 2013/03/19 01:07:34]

good point.. is it safe to assume that the font height will remain the same
after DeriveFont(0, new_style)? If so the new version should work fine. 

[Evan Stade, 2013/03/19 04:49:29]

height and width would both need to stay the same (width for wrapping). I don't
think bolding text keeps the same width. There may be styles that change the
height, I dunno.

[tonibarzic, 2013/03/19 16:27:53]

Yes, I understand that width is important for wrapping, but patchset 6 should
handle that... the wrapping is calculated with the font style of the next text
chunk that should be laid out. 
I guess the words that contain different font styles could still get broken at
the style breaks, but I'm not sure how much we care about that use case at this
point.

ps. supporting only underlined style is enough for my needs, so I'd be happy to
limit possible font styles to NORMAL and UNDERLINED (both of which we already
have embedded in the label)

+
+  return scoped_ptr<View>(result.release());
+}
+
 }  // namespace
 
-bool StyledLabel::LinkRange::operator<(
-    const StyledLabel::LinkRange& other) const {
+
+StyledLabel::RangeStyleInfo::RangeStyleInfo()
+    : font_style(gfx::Font::NORMAL),
+      disable_line_wrapping(false),
+      linkify(false) {
+}
+
+StyledLabel::RangeStyleInfo::~RangeStyleInfo() {}
+
+bool StyledLabel::StyleRange::operator<(
+    const StyledLabel::StyleRange& other) const {
   // Intentionally reversed so the priority queue is sorted by smallest first.
   return range.start() > other.range.start();
 }
 
 StyledLabel::StyledLabel(const string16& text, StyledLabelListener* listener)
     : text_(text),
       listener_(listener) {}
 
 StyledLabel::~StyledLabel() {}
 
 void StyledLabel::AddLink(const ui::Range& range) {
   DCHECK(!range.is_reversed());
   DCHECK(!range.is_empty());
   DCHECK(ui::Range(0, text_.size()).Contains(range));
-  link_ranges_.push(LinkRange(range));
+
+  RangeStyleInfo style_info;
+  style_info.disable_line_wrapping = true;
+  style_info.linkify = true;
+  style_info.font_style = gfx::Font::UNDERLINE;
+  style_ranges_.push(StyleRange(range, style_info));
+
   calculated_size_ = gfx::Size();
   InvalidateLayout();
 }
+
+void StyledLabel::AddStyleRange(const ui::Range& range,
+                                const RangeStyleInfo& style_info) {
+  DCHECK(!range.is_reversed());
+  DCHECK(!range.is_empty());
+  DCHECK(ui::Range(0, text_.size()).Contains(range));
+
+  style_ranges_.push(StyleRange(range, style_info));
+
+  calculated_size_ = gfx::Size();
+  InvalidateLayout();
+}
 
 gfx::Insets StyledLabel::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
   const gfx::Insets focus_border_padding(1, 1, 1, 1);
   insets += focus_border_padding;
   return insets;
 }
 
 int StyledLabel::GetHeightForWidth(int w) {
   if (w != calculated_size_.width())
@@ skipping 21 matching lines @@
     return 0;
 
   const int line_height = CalculateLineHeight();
   // The index of the line we're on.
   int line = 0;
   // The x position (in pixels) of the line we're on, relative to content
   // bounds.
   int x = 0;
 
   string16 remaining_string = text_;
-  std::priority_queue<LinkRange> link_ranges = link_ranges_;
+  std::priority_queue<StyleRange> style_ranges = style_ranges_;
 
   // Iterate over the text, creating a bunch of labels and links and laying them
   // out in the appropriate positions.
   while (!remaining_string.empty()) {
     // Don't put whitespace at beginning of a line.
     if (x == 0)
       TrimWhitespace(remaining_string, TRIM_LEADING, &remaining_string);
 
     ui::Range range(ui::Range::InvalidRange());
-    if (!link_ranges.empty())
-      range = link_ranges.top().range;
+    if (!style_ranges.empty())
+      range = style_ranges.top().range;
 
     const gfx::Rect chunk_bounds(x, 0, width - x, 2 * line_height);
     std::vector<string16> substrings;
     ui::ElideRectangleText(remaining_string,
                            gfx::Font(),
                            chunk_bounds.width(),
                            chunk_bounds.height(),
                            ui::IGNORE_LONG_WORDS,
                            &substrings);
 
+    // This happens when only whitespace is left.

[Evan Stade, 2013/03/18 23:20:50]

it doesn't seem like this should be what happens if only whitespace is left. It
seems to imply we may not respect trailing whitespace. If we want to not respect
trailing whitespace, the cleanest solution would be to trim it when first
setting the text.

[tbarzic, 2013/03/19 01:07:34]

yeah we could do that, the downside is trimming the text when it's set could
make the label setup a bit messier (e.g. to properly handle the following case:
label = StyledLabel(text);
label->SetLink(Range(2, text.length());

[Evan Stade, 2013/03/25 22:30:11]

but you still don't handle that correctly, because instead of styling the
trailing whitespace, you lop it off (sometimes). So either handle it correctly
or don't handle it at all, such that the above code might be considered illegal
if |text| has trailing whitespace.

[tbarzic, 2013/03/26 21:32:33]

ok then, added trimming in the constructor.
note that the algorithm doesn't respect leading whitespace either, so trimming
both ways (or should we not trim whitespace at the first line beginning)

+    if (substrings.empty())
+      break;
+
     string16 chunk = substrings[0];
     if (chunk.empty()) {
       // Nothing fit on this line. Start a new line. If x is 0, there's no room
       // for anything. Just abort.
       if (x == 0)
         break;
 
       x = 0;
       line++;
       continue;
     }
 
     scoped_ptr<View> view;
     const size_t position = text_.size() - remaining_string.size();
     if (position >= range.start()) {
-      // This chunk is a link.
-      if (chunk.size() < range.length() && x != 0) {
-        // Don't wrap links. Try to fit them entirely on one line.
+      const RangeStyleInfo& style_info = style_ranges.top().style_info;
+
+      if (style_info.disable_line_wrapping && chunk.size() < range.length() &&
+          position == range.start() && x != 0) {
+        // If the chunk should not be wrapped, try to fit it entirely on the
+        // next line.
         x = 0;
         line++;
         continue;
       }
 
-      chunk = chunk.substr(0, range.length());
-      Link* link = new Link(chunk);
-      link->set_listener(this);
-      if (!dry_run)
-        link_targets_[link] = range;
-      view.reset(link);
-      link_ranges.pop();
+      chunk = chunk.substr(0, std::min(chunk.size(), range.end() - position));
+
+      view = CreateLabelRange(chunk, style_info, this);
+
+      if (style_info.linkify && !dry_run)
+        link_targets_[view.get()] = range;
+
+      if (position + chunk.size() >= range.end())
+        style_ranges.pop();
     } else {
       // This chunk is normal text.
       if (position + chunk.size() > range.start())
         chunk = chunk.substr(0, range.start() - position);
-
-      Label* label = new Label(chunk);
-      // Give the label a focus border so that its preferred size matches
-      // links' preferred sizes.
-      label->SetHasFocusBorder(true);
-      view.reset(label);
+      view = CreateLabelRange(chunk, RangeStyleInfo(), this);
     }
 
     // Lay out the views to overlap by 1 pixel to compensate for their border
     // spacing. Otherwise, "<a>link</a>," will render as "link ,".
     const int overlap = 1;
     const gfx::Size view_size = view->GetPreferredSize();
     DCHECK_EQ(line_height, view_size.height() - 2 * overlap);
     if (!dry_run) {
       view->SetBoundsRect(gfx::Rect(
           gfx::Point(GetInsets().left() + x - overlap,
                      GetInsets().top() + line * line_height - overlap),
           view_size));
       AddChildView(view.release());
     }
     x += view_size.width() - 2 * overlap;
 
     remaining_string = remaining_string.substr(chunk.size());
   }
 
   return (line + 1) * line_height + GetInsets().height();
 }
 
 }  // namespace views