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