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));
+
+  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) {}
+    : listener_(listener) {
+  TrimWhitespace(text, TRIM_ALL, &text_);

[sky, 2013/03/28 16:02:09]

Is there a reason to do this? I ask as presumably any styles added are going to
be calculated from the text passed in. If TrimWhitespace removed leading
whitespace then all those calculations would be off.

[Evan Stade, 2013/03/28 17:03:07]

that's true, I guess you should only trim trailing and let the Trim in
CalculateAndDoLayout handle leading.

[tbarzic, 2013/03/28 20:33:58]

yeah, I had similar thought last night but haven't had chance to update the
code.

the StyledLabel now respects leading whitespace, provided that the first line
would not be empty (in which case leading whitespace is ignored).

+}
 
 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;

[sky, 2013/03/28 16:02:09]

Can't this be implemented in terms of AddStyleRange now?

[tbarzic, 2013/03/28 20:33:58]

Done.

(Added static RangeStyleInfo::CreateForLink (the link default style values
differ from the label's so I think this would be useful))

+  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_;

[sky, 2013/03/28 16:02:09]

Why do we copy here? style_ranges_ isn't going to change during this, right?

[Evan Stade, 2013/03/28 17:03:07]

no, but |style_ranges| is

[tbarzic, 2013/03/28 20:33:58]

as Evan said, |style_range| gets emptied.

if you're too concerned about this, I could work something out so we don't have
to copy all the ranges (e.g. using set and just iteration over it)

 
   // 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 size_t position = text_.size() - remaining_string.size();
 
     const gfx::Rect chunk_bounds(x, 0, width - x, 2 * line_height);
     std::vector<string16> substrings;
+    gfx::Font text_font;
+    // If the start of the remaining text is inside a styled range, the font
+    // style may differ from the base font. The font specified by the range
+    // should be used when eliding text.
+    if (position >= range.start()) {
+      text_font =
+          text_font.DeriveFont(0, style_ranges.top().style_info.font_style);
+    }
     ui::ElideRectangleText(remaining_string,
-                           gfx::Font(),
+                           text_font,
                            chunk_bounds.width(),
                            chunk_bounds.height(),
                            ui::IGNORE_LONG_WORDS,
                            &substrings);
 
+    DCHECK(!substrings.empty());
     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