Move allow_character_break property to RenderText.

ui/views/controls/label.cc

 // Copyright (c) 2012 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/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
@@ skipping 132 matching lines @@
 
 void Label::SetObscured(bool obscured) {
   if (this->obscured() == obscured)
     return;
   is_first_paint_text_ = true;
   render_text_->SetObscured(obscured);
   ResetLayout();
 }
 
 void Label::SetAllowCharacterBreak(bool allow_character_break) {
-  if (allow_character_break_ == allow_character_break)
+  const gfx::WordWrapBehavior behavior =
+      allow_character_break ? gfx::WRAP_LONG_WORDS : gfx::TRUNCATE_LONG_WORDS;
+  if (render_text_->word_wrap_behavior() == behavior)
     return;
   is_first_paint_text_ = true;
-  allow_character_break_ = allow_character_break;
+  render_text_->SetWordWrapBehavior(behavior);
   ResetLayout();

[msw, 2015/03/26 19:36:30]

nit: perhaps the layout shouldn't be reset (nor should we toggle
|is_first_paint_text_|) if the label isn't multiline.

[Jun Mukai, 2015/03/26 22:47:39]

Done.

 }
 
 void Label::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
   DCHECK(!multi_line() || (elide_behavior_ == gfx::ELIDE_TAIL ||
                            elide_behavior_ == gfx::NO_ELIDE));
   if (elide_behavior_ == elide_behavior)
     return;
   is_first_paint_text_ = true;
   elide_behavior_ = elide_behavior;
   ResetLayout();
@@ skipping 83 matching lines @@
 
 int Label::GetHeightForWidth(int w) const {
   if (!visible() && collapse_when_hidden_)
     return 0;
 
   w -= GetInsets().width();
   if (!multi_line() || text().empty() || w <= 0)
     return std::max(line_height(), font_list().GetHeight());
 
   int height = 0;
-  // RenderText doesn't support character breaks.
-  // TODO(mukai): remove this restriction.
-  if (render_text_->MultilineSupported() && !allow_character_break_) {
+  if (render_text_->MultilineSupported()) {
     // SetDisplayRect() has a side effect for later calls of GetStringSize().
     // Be careful to invoke |render_text_->SetDisplayRect(gfx::Rect())| to
     // cancel this effect before the next time GetStringSize() is called.
     // It would be beneficial not to cancel here, considering that some layout
     // managers invoke GetHeightForWidth() for the same width multiple times
     // and |render_text_| can cache the height.
     render_text_->SetDisplayRect(gfx::Rect(0, 0, w, 0));
     height = render_text_->GetStringSize().height();
   } else {
     std::vector<base::string16> lines = GetLinesForWidth(w);
@@ skipping 103 matching lines @@
 
 void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
   render_text_.reset(gfx::RenderText::CreateInstance());
   render_text_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
   render_text_->SetDirectionalityMode(gfx::DIRECTIONALITY_FROM_TEXT);
   // NOTE: |render_text_| should not be elided at all. This is used to keep some
   // properties and to compute the size of the string.
   render_text_->SetElideBehavior(gfx::NO_ELIDE);
   render_text_->SetFontList(font_list);
   render_text_->SetCursorEnabled(false);
+  render_text_->SetWordWrapBehavior(gfx::TRUNCATE_LONG_WORDS);
 
   elide_behavior_ = gfx::ELIDE_TAIL;
   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
   subpixel_rendering_enabled_ = true;
   auto_color_readability_ = true;
   multi_line_ = false;
   UpdateColorsFromTheme(ui::NativeTheme::instance());
   handles_tooltips_ = true;
   collapse_when_hidden_ = false;
-  allow_character_break_ = false;
   max_width_ = 0;
   is_first_paint_text_ = true;
   SetText(text);
 }
 
 void Label::ResetLayout() {
   InvalidateLayout();
   PreferredSizeChanged();
   SchedulePaint();
   lines_.clear();
@@ skipping 37 matching lines @@
     if (alignment == gfx::ALIGN_TO_HEAD)
       alignment = rtl ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
     directionality =
         rtl ? gfx::DIRECTIONALITY_FORCE_RTL : gfx::DIRECTIONALITY_FORCE_LTR;
   }
 
   // Text eliding is not supported for multi-lined Labels.
   // TODO(mukai): Add multi-lined elided text support.
   gfx::ElideBehavior elide_behavior =
       multi_line() ? gfx::NO_ELIDE : elide_behavior_;
-  if (!multi_line() ||
-      (render_text_->MultilineSupported() && !allow_character_break_)) {
+  if (!multi_line() || render_text_->MultilineSupported()) {
     scoped_ptr<gfx::RenderText> render_text =
         CreateRenderText(text(), alignment, directionality, elide_behavior);
     render_text->SetDisplayRect(rect);
     render_text->SetMultiline(multi_line());
+    render_text->SetWordWrapBehavior(render_text_->word_wrap_behavior());
     lines_.push_back(render_text.release());
   } else {
     std::vector<base::string16> lines = GetLinesForWidth(rect.width());
     if (lines.size() > 1)
       rect.set_height(std::max(line_height(), font_list().GetHeight()));
 
     const int bottom = GetContentsBounds().bottom();
     for (size_t i = 0; i < lines.size() && rect.y() <= bottom; ++i) {
       scoped_ptr<gfx::RenderText> line =
           CreateRenderText(lines[i], alignment, directionality, elide_behavior);
@@ skipping 27 matching lines @@
   return focus_bounds;
 }
 
 std::vector<base::string16> Label::GetLinesForWidth(int width) const {
   std::vector<base::string16> lines;
   // |width| can be 0 when getting the default text size, in that case
   // the ideal lines (i.e. broken at newline characters) are wanted.
   if (width <= 0) {
     base::SplitString(render_text_->GetDisplayText(), '\n', &lines);
   } else {
-    const gfx::WordWrapBehavior wrap = allow_character_break_
-                                           ? gfx::WRAP_LONG_WORDS
-                                           : gfx::TRUNCATE_LONG_WORDS;
     gfx::ElideRectangleText(render_text_->GetDisplayText(), font_list(), width,
-                            std::numeric_limits<int>::max(), wrap, &lines);
+                            std::numeric_limits<int>::max(),
+                            render_text_->word_wrap_behavior(), &lines);
   }
   return lines;
 }
 
 gfx::Size Label::GetTextSize() const {
   gfx::Size size;
   if (text().empty()) {
     size = gfx::Size(0, std::max(line_height(), font_list().GetHeight()));
-  } else if (!multi_line() ||
-             (render_text_->MultilineSupported() && !allow_character_break_)) {
+  } else if (!multi_line() || render_text_->MultilineSupported()) {
     // Cancel the display rect of |render_text_|. The display rect may be
     // specified in GetHeightForWidth(), and specifying empty Rect cancels
     // its effect. See also the comment in GetHeightForWidth().
     // TODO(mukai): use gfx::Rect() to compute the ideal size rather than
     // the current width(). See crbug.com/468494, crbug.com/467526, and
     // the comment for MultilinePreferredSizeTest in label_unittest.cc.
     render_text_->SetDisplayRect(gfx::Rect(0, 0, width(), 0));
     size = render_text_->GetStringSize();
   } else {
     // Get the natural text size, unelided and only wrapped on newlines.
@@ skipping 49 matching lines @@
 }
 
 bool Label::ShouldShowDefaultTooltip() const {
   const gfx::Size text_size = GetTextSize();
   const gfx::Size size = GetContentsBounds().size();
   return !obscured() && (text_size.width() > size.width() ||
                          (multi_line() && text_size.height() > size.height()));
 }
 
 }  // namespace views