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 16 namespace { 17 18 const size_t kPreferredLinesCacheSize = 10; 19 20 } // namespace 21 22 namespace 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 34 class 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 75 InnerBoundedLabel::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 85 InnerBoundedLabel::~InnerBoundedLabel() { 86 } 87 88 void InnerBoundedLabel::SetNativeTheme(const ui::NativeTheme* theme) { 89 ClearCaches(); 90 OnNativeThemeChanged(theme); 91 } 92 93 int 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 105 gfx::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 127 std::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 166 void InnerBoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) { 167 ClearCaches(); 168 views::Label::OnBoundsChanged(previous_bounds); 169 } 170 171 void 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 189 void InnerBoundedLabel::SetText(const base::string16& text) { 190 views::Label::SetText(text); 191 ClearCaches(); 192 } 193 194 int 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 217 void 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 226 int 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 237 void 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 246 gfx::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 258 void 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 270 BoundedLabel::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 278 BoundedLabel::BoundedLabel(const base::string16& text) 279 : line_limit_(-1) { 280 label_.reset(new InnerBoundedLabel(*this)); 281 label_->SetText(text); 282 } 283 284 BoundedLabel::~BoundedLabel() { 285 } 286 287 void BoundedLabel::SetColors(SkColor textColor, SkColor backgroundColor) { 288 label_->SetEnabledColor(textColor); 289 label_->SetBackgroundColor(backgroundColor); 290 } 291 292 void BoundedLabel::SetLineHeight(int height) { 293 label_->SetLineHeight(height); 294 } 295 296 void BoundedLabel::SetLineLimit(int lines) { 297 line_limit_ = std::max(lines, -1); 298 } 299 300 void BoundedLabel::SetText(const base::string16& text) { 301 label_->SetText(text); 302 } 303 304 int BoundedLabel::GetLineHeight() const { 305 return label_->line_height(); 306 } 307 308 int BoundedLabel::GetLineLimit() const { 309 return line_limit_; 310 } 311 312 int BoundedLabel::GetLinesForWidthAndLimit(int width, int limit) { 313 return visible() ? label_->GetLinesForWidthAndLimit(width, limit) : 0; 314 } 315 316 gfx::Size BoundedLabel::GetSizeForWidthAndLines(int width, int lines) { 317 return visible() ? 318 label_->GetSizeForWidthAndLines(width, lines) : gfx::Size(); 319 } 320 321 int BoundedLabel::GetBaseline() const { 322 return label_->GetBaseline(); 323 } 324 325 gfx::Size BoundedLabel::GetPreferredSize() const { 326 return visible() ? label_->GetSizeForWidthAndLines(-1, -1) : gfx::Size(); 327 } 328 329 int BoundedLabel::GetHeightForWidth(int width) const { 330 return visible() ? 331 label_->GetSizeForWidthAndLines(width, line_limit_).height() : 0; 332 } 333 334 void BoundedLabel::Paint(gfx::Canvas* canvas, const views::CullSet& cull_set) { 335 if (visible()) 336 label_->Paint(canvas, cull_set); 337 } 338 339 bool BoundedLabel::CanProcessEventsWithinSubtree() const { 340 return label_->CanProcessEventsWithinSubtree(); 341 } 342 343 void BoundedLabel::GetAccessibleState(ui::AXViewState* state) { 344 label_->GetAccessibleState(state); 345 } 346 347 void BoundedLabel::OnBoundsChanged(const gfx::Rect& previous_bounds) { 348 label_->SetBoundsRect(bounds()); 349 views::View::OnBoundsChanged(previous_bounds); 350 } 351 352 void BoundedLabel::OnNativeThemeChanged(const ui::NativeTheme* theme) { 353 label_->SetNativeTheme(theme); 354 } 355 356 base::string16 BoundedLabel::GetWrappedTextForTest(int width, int lines) { 357 return JoinString(label_->GetWrappedText(width, lines), '\n'); 358 } 359 360 } // namespace message_center 361
