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/message_center/views/bounded_label.h"
6
7#include <limits>
8
9#include "base/strings/string_util.h"
10#include "base/strings/utf_string_conversions.h"
11#include "ui/gfx/canvas.h"
12#include "ui/gfx/text_elider.h"
13#include "ui/gfx/text_utils.h"
14#include "ui/views/controls/label.h"
15
16namespace {
17
18const size_t kPreferredLinesCacheSize = 10;
19
20}  // namespace
21
22namespace message_center {
23
24// InnerBoundedLabel ///////////////////////////////////////////////////////////
25
26// InnerBoundedLabel is a views::Label subclass that does all of the work for
27// BoundedLabel. It is kept private to prevent outside code from calling a
28// number of views::Label methods like SetFontList() that break BoundedLabel's
29// caching but can't be overridden.
30//
31// TODO(dharcourt): Move the line limiting functionality to views::Label to make
32// this unnecessary.
33
34class InnerBoundedLabel : public views::Label {
35 public:
36  InnerBoundedLabel(const BoundedLabel& owner);
37  virtual ~InnerBoundedLabel();
38
39  void SetNativeTheme(const ui::NativeTheme* theme);
40
41  // Pass in a -1 width to use the preferred width, a -1 limit to skip limits.
42  int GetLinesForWidthAndLimit(int width, int limit);
43  gfx::Size GetSizeForWidthAndLines(int width, int lines);
44  std::vector<base::string16> GetWrappedText(int width, int lines);
45
46  // Overridden from views::Label.
47  virtual void SetText(const base::string16& text) OVERRIDE;
48
49 protected:
50  // Overridden from views::Label.
51  virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
52  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
53
54 private:
55  int GetTextFlags();
56
57  void ClearCaches();
58  int GetCachedLines(int width);
59  void SetCachedLines(int width, int lines);
60  gfx::Size GetCachedSize(const std::pair<int, int>& width_and_lines);
61  void SetCachedSize(std::pair<int, int> width_and_lines, gfx::Size size);
62
63  const BoundedLabel* owner_;  // Weak reference.
64  base::string16 wrapped_text_;
65  int wrapped_text_width_;
66  int wrapped_text_lines_;
67  std::map<int, int> lines_cache_;
68  std::list<int> lines_widths_;  // Most recently used in front.
69  std::map<std::pair<int, int>, gfx::Size> size_cache_;
70  std::list<std::pair<int, int> > size_widths_and_lines_;  // Recent in front.
71
72  DISALLOW_COPY_AND_ASSIGN(InnerBoundedLabel);
73};
74
75InnerBoundedLabel::InnerBoundedLabel(const BoundedLabel& owner)
76    : owner_(&owner),
77      wrapped_text_width_(0),
78      wrapped_text_lines_(0) {
79  SetMultiLine(true);
80  SetAllowCharacterBreak(true);
81  SetHorizontalAlignment(gfx::ALIGN_LEFT);
82  set_collapse_when_hidden(true);
83}
84
85InnerBoundedLabel::~InnerBoundedLabel() {
86}
87
88void InnerBoundedLabel::SetNativeTheme(const ui::NativeTheme* theme) {
89  ClearCaches();
90  OnNativeThemeChanged(theme);
91}
92
93int InnerBoundedLabel::GetLinesForWidthAndLimit(int width, int limit) {
94  if (width == 0 || limit == 0)
95    return 0;
96  int lines = GetCachedLines(width);
97  if (lines == std::numeric_limits<int>::max()) {
98    int text_width = std::max(width - owner_->GetInsets().width(), 0);
99    lines = GetWrappedText(text_width, lines).size();
100    SetCachedLines(width, lines);
101  }
102  return (limit < 0 || lines <= limit) ? lines : limit;
103}
104
105gfx::Size InnerBoundedLabel::GetSizeForWidthAndLines(int width, int lines) {
106  if (width == 0 || lines == 0)
107    return gfx::Size();
108  std::pair<int, int> key(width, lines);
109  gfx::Size size = GetCachedSize(key);
110  if (size.height() == std::numeric_limits<int>::max()) {
111    gfx::Insets insets = owner_->GetInsets();
112    int text_width = (width < 0) ? std::numeric_limits<int>::max() :
113                                   std::max(width - insets.width(), 0);
114    int text_height = std::numeric_limits<int>::max();
115    std::vector<base::string16> wrapped = GetWrappedText(text_width, lines);
116    gfx::Canvas::SizeStringInt(JoinString(wrapped, '\n'), font_list(),
117                               &text_width, &text_height,
118                               owner_->GetLineHeight(),
119                               GetTextFlags());
120    size.set_width(text_width + insets.width());
121    size.set_height(text_height + insets.height());
122    SetCachedSize(key, size);
123  }
124  return size;
125}
126
127std::vector<base::string16> InnerBoundedLabel::GetWrappedText(int width,
128                                                              int lines) {
129  // Short circuit simple case.
130  if (width == 0 || lines == 0)
131    return std::vector<base::string16>();
132
133  // Restrict line limit to ensure (lines + 1) * line_height <= INT_MAX and
134  // use it to calculate a reasonable text height.
135  int height = std::numeric_limits<int>::max();
136  if (lines > 0) {
137    int line_height = std::max(font_list().GetHeight(),
138                               2);  // At least 2 pixels.
139    int max_lines = std::numeric_limits<int>::max() / line_height - 1;
140    lines = std::min(lines, max_lines);
141    height = (lines + 1) * line_height;
142  }
143
144  // Wrap, using INT_MAX for -1 widths that indicate no wrapping.
145  std::vector<base::string16> wrapped;
146  gfx::ElideRectangleText(text(), font_list(),
147                          (width < 0) ? std::numeric_limits<int>::max() : width,
148                          height, gfx::WRAP_LONG_WORDS, &wrapped);
149
150  // Elide if necessary.
151  if (lines > 0 && wrapped.size() > static_cast<unsigned int>(lines)) {
152    // Add an ellipsis to the last line. If this ellipsis makes the last line
153    // too wide, that line will be further elided by the gfx::ElideText below,
154    // so for example "ABC" could become "ABC..." and then "AB...".
155    base::string16 last =
156        wrapped[lines - 1] + base::UTF8ToUTF16(gfx::kEllipsis);
157    if (width > 0 && gfx::GetStringWidth(last, font_list()) > width)
158      last = gfx::ElideText(last, font_list(), width, gfx::ELIDE_TAIL);
159    wrapped.resize(lines - 1);
160    wrapped.push_back(last);
161  }
162
163  return wrapped;
164}
165
166void InnerBoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) {
167  ClearCaches();
168  views::Label::OnBoundsChanged(previous_bounds);
169}
170
171void InnerBoundedLabel::OnPaint(gfx::Canvas* canvas) {
172  views::Label::OnPaintBackground(canvas);
173  views::Label::OnPaintBorder(canvas);
174  int lines = owner_->GetLineLimit();
175  int height = GetSizeForWidthAndLines(width(), lines).height();
176  if (height > 0) {
177    gfx::Rect bounds(width(), height);
178    bounds.Inset(owner_->GetInsets());
179    if (bounds.width() != wrapped_text_width_ || lines != wrapped_text_lines_) {
180      wrapped_text_ = JoinString(GetWrappedText(bounds.width(), lines), '\n');
181      wrapped_text_width_ = bounds.width();
182      wrapped_text_lines_ = lines;
183    }
184    bounds.set_x(GetMirroredXForRect(bounds));
185    PaintText(canvas, wrapped_text_, bounds, GetTextFlags());
186  }
187}
188
189void InnerBoundedLabel::SetText(const base::string16& text) {
190  views::Label::SetText(text);
191  ClearCaches();
192}
193
194int InnerBoundedLabel::GetTextFlags() {
195  int flags = gfx::Canvas::MULTI_LINE | gfx::Canvas::CHARACTER_BREAK;
196
197  // We can't use subpixel rendering if the background is non-opaque.
198  if (SkColorGetA(background_color()) != 0xFF)
199    flags |= gfx::Canvas::NO_SUBPIXEL_RENDERING;
200
201  if (directionality_mode() == gfx::DIRECTIONALITY_FORCE_LTR) {
202    flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
203  } else if (directionality_mode() == gfx::DIRECTIONALITY_FORCE_RTL) {
204    flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
205  } else if (directionality_mode() == gfx::DIRECTIONALITY_FROM_TEXT) {
206    base::i18n::TextDirection direction =
207        base::i18n::GetFirstStrongCharacterDirection(text());
208    if (direction == base::i18n::RIGHT_TO_LEFT)
209      flags |= gfx::Canvas::FORCE_RTL_DIRECTIONALITY;
210    else
211      flags |= gfx::Canvas::FORCE_LTR_DIRECTIONALITY;
212  }
213
214  return flags;
215}
216
217void InnerBoundedLabel::ClearCaches() {
218  wrapped_text_width_ = 0;
219  wrapped_text_lines_ = 0;
220  lines_cache_.clear();
221  lines_widths_.clear();
222  size_cache_.clear();
223  size_widths_and_lines_.clear();
224}
225
226int InnerBoundedLabel::GetCachedLines(int width) {
227  int lines = std::numeric_limits<int>::max();
228  std::map<int, int>::const_iterator found;
229  if ((found = lines_cache_.find(width)) != lines_cache_.end()) {
230    lines = found->second;
231    lines_widths_.remove(width);
232    lines_widths_.push_front(width);
233  }
234  return lines;
235}
236
237void InnerBoundedLabel::SetCachedLines(int width, int lines) {
238  if (lines_cache_.size() >= kPreferredLinesCacheSize) {
239    lines_cache_.erase(lines_widths_.back());
240    lines_widths_.pop_back();
241  }
242  lines_cache_[width] = lines;
243  lines_widths_.push_front(width);
244}
245
246gfx::Size InnerBoundedLabel::GetCachedSize(
247    const std::pair<int, int>& width_and_lines) {
248  gfx::Size size(width_and_lines.first, std::numeric_limits<int>::max());
249  std::map<std::pair<int, int>, gfx::Size>::const_iterator found;
250  if ((found = size_cache_.find(width_and_lines)) != size_cache_.end()) {
251    size = found->second;
252    size_widths_and_lines_.remove(width_and_lines);
253    size_widths_and_lines_.push_front(width_and_lines);
254  }
255  return size;
256}
257
258void InnerBoundedLabel::SetCachedSize(std::pair<int, int> width_and_lines,
259                                      gfx::Size size) {
260  if (size_cache_.size() >= kPreferredLinesCacheSize) {
261    size_cache_.erase(size_widths_and_lines_.back());
262    size_widths_and_lines_.pop_back();
263  }
264  size_cache_[width_and_lines] = size;
265  size_widths_and_lines_.push_front(width_and_lines);
266}
267
268// BoundedLabel ///////////////////////////////////////////////////////////
269
270BoundedLabel::BoundedLabel(const base::string16& text,
271                           const gfx::FontList& font_list)
272    : line_limit_(-1) {
273  label_.reset(new InnerBoundedLabel(*this));
274  label_->SetFontList(font_list);
275  label_->SetText(text);
276}
277
278BoundedLabel::BoundedLabel(const base::string16& text)
279    : line_limit_(-1) {
280  label_.reset(new InnerBoundedLabel(*this));
281  label_->SetText(text);
282}
283
284BoundedLabel::~BoundedLabel() {
285}
286
287void BoundedLabel::SetColors(SkColor textColor, SkColor backgroundColor) {
288  label_->SetEnabledColor(textColor);
289  label_->SetBackgroundColor(backgroundColor);
290}
291
292void BoundedLabel::SetLineHeight(int height) {
293  label_->SetLineHeight(height);
294}
295
296void BoundedLabel::SetLineLimit(int lines) {
297  line_limit_ = std::max(lines, -1);
298}
299
300void BoundedLabel::SetText(const base::string16& text) {
301  label_->SetText(text);
302}
303
304int BoundedLabel::GetLineHeight() const {
305  return label_->line_height();
306}
307
308int BoundedLabel::GetLineLimit() const {
309  return line_limit_;
310}
311
312int BoundedLabel::GetLinesForWidthAndLimit(int width, int limit) {
313  return visible() ? label_->GetLinesForWidthAndLimit(width, limit) : 0;
314}
315
316gfx::Size BoundedLabel::GetSizeForWidthAndLines(int width, int lines) {
317  return visible() ?
318         label_->GetSizeForWidthAndLines(width, lines) : gfx::Size();
319}
320
321int BoundedLabel::GetBaseline() const {
322  return label_->GetBaseline();
323}
324
325gfx::Size BoundedLabel::GetPreferredSize() const {
326  return visible() ? label_->GetSizeForWidthAndLines(-1, -1) : gfx::Size();
327}
328
329int BoundedLabel::GetHeightForWidth(int width) const {
330  return visible() ?
331         label_->GetSizeForWidthAndLines(width, line_limit_).height() : 0;
332}
333
334void BoundedLabel::Paint(gfx::Canvas* canvas, const views::CullSet& cull_set) {
335  if (visible())
336    label_->Paint(canvas, cull_set);
337}
338
339bool BoundedLabel::CanProcessEventsWithinSubtree() const {
340  return label_->CanProcessEventsWithinSubtree();
341}
342
343void BoundedLabel::GetAccessibleState(ui::AXViewState* state) {
344  label_->GetAccessibleState(state);
345}
346
347void BoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) {
348  label_->SetBoundsRect(bounds());
349  views::View::OnBoundsChanged(previous_bounds);
350}
351
352void BoundedLabel::OnNativeThemeChanged(const ui::NativeTheme* theme) {
353  label_->SetNativeTheme(theme);
354}
355
356base::string16 BoundedLabel::GetWrappedTextForTest(int width, int lines) {
357  return JoinString(label_->GetWrappedText(width, lines), '\n');
358}
359
360}  // namespace message_center
361