Prepare to use gfx::RenderText in views::Label.

ui/views/controls/button/label_button.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/button/label_button.h"
 
 #include "base/logging.h"
 #include "grit/ui_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/animation/throb_animation.h"
@@ skipping 83 matching lines @@
 void LabelButton::SetTextColor(ButtonState for_state, SkColor color) {
   button_state_colors_[for_state] = color;
   if (for_state == STATE_DISABLED)
     label_->SetDisabledColor(color);
   else if (for_state == state())
     label_->SetEnabledColor(color);
   explicitly_set_colors_[for_state] = true;
 }
 
 void LabelButton::SetTextShadows(const gfx::ShadowValues& shadows) {
-  label_->set_shadows(shadows);
+  label_->SetShadows(shadows);
 }
 
 void LabelButton::SetTextSubpixelRenderingEnabled(bool enabled) {
-  label_->set_subpixel_rendering_enabled(enabled);
+  label_->SetSubpixelRenderingEnabled(enabled);
 }
 
 bool LabelButton::GetTextMultiLine() const {
-  return label_->is_multi_line();
+  return label_->multi_line();
 }
 
 void LabelButton::SetTextMultiLine(bool text_multi_line) {
   label_->SetMultiLine(text_multi_line);
 }
 
 const gfx::FontList& LabelButton::GetFontList() const {
   return label_->font_list();
 }
 
 void LabelButton::SetFontList(const gfx::FontList& font_list) {
   cached_normal_font_list_ = font_list;
   cached_bold_font_list_ = font_list.DeriveWithStyle(
       font_list.GetFontStyle() | gfx::Font::BOLD);
 
   // STYLE_BUTTON uses bold text to indicate default buttons.
   label_->SetFontList(
       style_ == STYLE_BUTTON && is_default_ ?
       cached_bold_font_list_ : cached_normal_font_list_);
 }
 
 void LabelButton::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
   label_->SetElideBehavior(elide_behavior);
 }
 
 gfx::HorizontalAlignment LabelButton::GetHorizontalAlignment() const {
-  return label_->GetHorizontalAlignment();
+  return label_->horizontal_alignment();
 }
 
 void LabelButton::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   label_->SetHorizontalAlignment(alignment);
   InvalidateLayout();
 }
 
-void LabelButton::SetDirectionalityMode(gfx::DirectionalityMode mode) {
-  label_->set_directionality_mode(mode);
-}
-
 void LabelButton::SetIsDefault(bool is_default) {
   if (is_default == is_default_)
     return;
   is_default_ = is_default;
   ui::Accelerator accel(ui::VKEY_RETURN, ui::EF_NONE);
   is_default_ ? AddAccelerator(accel) : RemoveAccelerator(accel);
 
   // STYLE_BUTTON uses bold text to indicate default buttons.
   if (style_ == STYLE_BUTTON) {
     label_->SetFontList(
@@ skipping 20 matching lines @@
   OnNativeThemeChanged(GetNativeTheme());
 }
 
 void LabelButton::SetFocusPainter(scoped_ptr<Painter> focus_painter) {
   focus_painter_ = focus_painter.Pass();
 }
 
 gfx::Size LabelButton::GetPreferredSize() const {
   // Use a temporary label copy for sizing to avoid calculation side-effects.
   Label label(GetText(), cached_normal_font_list_);
-  label.set_shadows(label_->shadows());
+  label.SetShadows(label_->shadows());
   label.SetMultiLine(GetTextMultiLine());
 
   if (style() == STYLE_BUTTON) {
     // Some text appears wider when rendered normally than when rendered bold.
     // Accommodate the widest, as buttons may show bold and shouldn't resize.
     const int current_width = label.GetPreferredSize().width();
     label.SetFontList(cached_bold_font_list_);
     if (label.GetPreferredSize().width() < current_width)
       label.SetFontList(cached_normal_font_list_);
   }
 
-  // Resize multi-line labels given the current limited available width.
+  // Calculate the required size.
   const gfx::Size image_size(image_->GetPreferredSize());
-  const int image_width = image_size.width();
-  if (GetTextMultiLine() && (width() > image_width + kSpacing))
-    label.SizeToFit(width() - image_width - (image_width > 0 ? kSpacing : 0));
-
-  // Calculate the required size.
   gfx::Size size(label.GetPreferredSize());
-  if (image_width > 0 && size.width() > 0)
+  if (image_size.width() > 0 && size.width() > 0)
     size.Enlarge(kSpacing, 0);
   size.SetToMax(gfx::Size(0, image_size.height()));
   const gfx::Insets insets(GetInsets());
   size.Enlarge(image_size.width() + insets.width(), insets.height());
 
   // Make the size at least as large as the minimum size needed by the border.
   size.SetToMax(border() ? border()->GetMinimumSize() : gfx::Size());
 
   // Increase the minimum size monotonically with the preferred size.
   size.SetToMax(min_size_);
   min_size_ = size;
 
   // Return the largest known size clamped to the maximum size (if valid).
   if (max_size_.width() > 0)
     size.set_width(std::min(max_size_.width(), size.width()));
   if (max_size_.height() > 0)
     size.set_height(std::min(max_size_.height(), size.height()));
   return size;
 }
 
+int LabelButton::GetHeightForWidth(int w) const {
+  w -= GetInsets().width();
+  const gfx::Size image_size(image_->GetPreferredSize());
+  w -= image_size.width();
+  if (image_size.width() > 0 && !GetText().empty())
+    w -= kSpacing;
+
+  int height = std::max(image_size.height(), label_->GetHeightForWidth(w));
+  if (border())
+    height = std::max(height, border()->GetMinimumSize().height());
+
+  height = std::max(height, min_size_.height());
+  if (max_size_.height() > 0)
+    height = std::min(height, max_size_.height());
+  return height;
+}
+
 void LabelButton::Layout() {
   gfx::HorizontalAlignment adjusted_alignment = GetHorizontalAlignment();
   if (base::i18n::IsRTL() && adjusted_alignment != gfx::ALIGN_CENTER)
     adjusted_alignment = (adjusted_alignment == gfx::ALIGN_LEFT) ?
         gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
 
   gfx::Rect child_area(GetChildAreaBounds());
   child_area.Inset(GetInsets());
 
   gfx::Size image_size(image_->GetPreferredSize());
   image_size.SetToMin(child_area.size());
 
   // The label takes any remaining width after sizing the image, unless both
   // views are centered. In that case, using the tighter preferred label width
   // avoids wasted space within the label that would look like awkward padding.
   gfx::Size label_size(child_area.size());
   if (!image_size.IsEmpty() && !label_size.IsEmpty()) {
     label_size.set_width(
         std::max(child_area.width() - image_size.width() - kSpacing, 0));
     if (adjusted_alignment == gfx::ALIGN_CENTER) {
       // Ensure multi-line labels paired with images use their available width.
-      if (GetTextMultiLine())
-        label_->SizeToFit(label_size.width());
       label_size.set_width(
           std::min(label_size.width(), label_->GetPreferredSize().width()));
     }
   }
 
   gfx::Point image_origin(child_area.origin());
   image_origin.Offset(0, (child_area.height() - image_size.height()) / 2);
   if (adjusted_alignment == gfx::ALIGN_CENTER) {
     const int total_width = image_size.width() + label_size.width() +
         ((image_size.width() > 0 && label_size.width() > 0) ? kSpacing : 0);
@@ skipping 65 matching lines @@
 
   // Certain styles do not change text color when hovered or pressed.
   bool constant_text_color = false;
   // Use hardcoded colors for inverted color scheme support and STYLE_BUTTON.
   if (gfx::IsInvertedColorScheme()) {
     constant_text_color = true;
     colors[STATE_NORMAL] = SK_ColorWHITE;
     label_->SetBackgroundColor(SK_ColorBLACK);
     label_->set_background(Background::CreateSolidBackground(SK_ColorBLACK));
     label_->SetAutoColorReadabilityEnabled(true);
-    label_->set_shadows(gfx::ShadowValues());
+    label_->SetShadows(gfx::ShadowValues());
   } else if (style() == STYLE_BUTTON) {
     // TODO(erg): This is disabled on desktop linux because of the binary asset
     // confusion. These details should either be pushed into ui::NativeThemeWin
     // or should be obsoleted by rendering buttons with paint calls instead of
     // with static assets. http://crbug.com/350498
 #if !(defined(OS_LINUX) && !defined(OS_CHROMEOS))
     constant_text_color = true;
     colors[STATE_NORMAL] = kStyleButtonTextColor;
     label_->SetBackgroundColor(theme->GetSystemColor(
         ui::NativeTheme::kColorId_ButtonBackgroundColor));
     label_->SetAutoColorReadabilityEnabled(false);
-    label_->set_shadows(gfx::ShadowValues(1,
-        gfx::ShadowValue(gfx::Point(0, 1), 0, kStyleButtonShadowColor)));
+    label_->SetShadows(gfx::ShadowValues(
+        1, gfx::ShadowValue(gfx::Point(0, 1), 0, kStyleButtonShadowColor)));
 #endif
     label_->set_background(NULL);
   } else {
     label_->set_background(NULL);
   }
 
   if (constant_text_color)
     colors[STATE_HOVERED] = colors[STATE_PRESSED] = colors[STATE_NORMAL];
 
   for (size_t state = STATE_NORMAL; state < STATE_COUNT; ++state) {
@@ skipping 82 matching lines @@
   return ui::NativeTheme::kNormal;
 }
 
 ui::NativeTheme::State LabelButton::GetForegroundThemeState(
     ui::NativeTheme::ExtraParams* params) const {
   GetExtraParams(params);
   return ui::NativeTheme::kHovered;
 }
 
 }  // namespace views