rAc: try really hard not to ellipsize addresses

chrome/browser/ui/views/autofill/autofill_dialog_views.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 "chrome/browser/ui/views/autofill/autofill_dialog_views.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 134 matching lines @@
 // It exists to circumvent shortcomings of GridLayout and BoxLayout (namely that
 // the former doesn't fully respect child visibility, and that the latter won't
 // expand a single child).
 class SectionRowView : public views::View {
  public:
   SectionRowView() {}
   virtual ~SectionRowView() {}
 
   // views::View implementation:
   virtual gfx::Size GetPreferredSize() OVERRIDE {
-    // Only the height matters anyway.
-    return child_at(2)->GetPreferredSize();
+    int h = 0;
+    int w = 0;

[Ilya Sherman, 2013/08/06 08:00:23]

nit: Please spell out "height" and "width" (throughout).

[Evan Stade, 2013/08/06 19:00:37]

I'll change it here, but the views function in view.h is defined as:

virtual int GetHeightForWidth(int w);

so I'd rather stick to that naming convention in the implementation of that
function.

[Evan Stade, 2013/08/06 19:34:53]

scratch that, all updated.

+    for (int i = 0; i < child_count(); ++i) {
+      if (child_at(i)->visible()) {
+        if (w > 0)
+          w += kAroundTextPadding;
+
+        gfx::Size size = child_at(i)->GetPreferredSize();
+        h = std::max(h, size.height());
+        w += size.width();
+      }
+    }
+
+    return gfx::Size(w, h);
   }
 
   virtual void Layout() OVERRIDE {
     const gfx::Rect bounds = GetContentsBounds();
 
     // Icon is left aligned.
     int start_x = bounds.x();
     views::View* icon = child_at(0);
     if (icon->visible()) {
       icon->SizeToPreferredSize();
@@ skipping 812 matching lines @@
 ui::MouseEvent AutofillDialogViews::SectionContainer::ProxyEvent(
     const ui::MouseEvent& event) {
   ui::MouseEvent event_copy = event;
   event_copy.set_location(gfx::Point());
   return event_copy;
 }
 
 // AutofilDialogViews::SuggestionView ------------------------------------------
 
 AutofillDialogViews::SuggestionView::SuggestionView(
-    const base::string16& edit_label,
     AutofillDialogViews* autofill_dialog)
     : label_(new views::Label()),
       label_line_2_(new views::Label()),
       icon_(new views::ImageView()),
-      label_container_(new SectionRowView()),
       decorated_(
           new DecoratedTextfield(base::string16(),
                                  base::string16(),
                                  autofill_dialog)) {
   // TODO(estade): Make this the correct color.
   set_border(
       views::Border::CreateSolidSidedBorder(1, 0, 0, 0, SK_ColorLTGRAY));
 
+  SectionRowView* label_container = new SectionRowView();
+  AddChildView(label_container);
+
   // Label and icon.
+  label_container->AddChildView(icon_);
   label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  label_container_->AddChildView(icon_);
-  label_container_->AddChildView(label_);
-  label_container_->AddChildView(decorated_);
+  label_container->AddChildView(label_);
+
+  // TODO(estade): get the sizing and spacing right on this textfield.
   decorated_->SetVisible(false);
-  // TODO(estade): get the sizing and spacing right on this textfield.
   decorated_->set_default_width_in_chars(10);
-  AddChildView(label_container_);
+  label_container->AddChildView(decorated_);
 
+  // TODO(estade): need to get the line height right.
   label_line_2_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label_line_2_->SetVisible(false);
   label_line_2_->SetMultiLine(true);
   AddChildView(label_line_2_);
 
   // TODO(estade): do something about this '2'.
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 2, 0));
 }
 
 AutofillDialogViews::SuggestionView::~SuggestionView() {}
 
-void AutofillDialogViews::SuggestionView::SetSuggestionText(
-    const base::string16& text,
-    gfx::Font::FontStyle text_style) {
-  label_->SetFont(ui::ResourceBundle::GetSharedInstance().GetFont(
-      ui::ResourceBundle::BaseFont).DeriveFont(0, text_style));
+gfx::Size AutofillDialogViews::SuggestionView::GetPreferredSize() {
+  // There's no preferred width. The parent's layout should get the preferred
+  // height from GetHeightForWidth().
+  return gfx::Size();
+}
 
+int AutofillDialogViews::SuggestionView::GetHeightForWidth(int w) {
+  int h = 0;
+  CanUseVerticallyCompactText(w, &h);
+  return h;
+}
+
+bool AutofillDialogViews::SuggestionView::CanUseVerticallyCompactText(
+    int available_width, int* resulting_height) {
+  // This calculation may be costly, avoid doing it more than once per width.
+  if (!calculated_heights_.count(available_width)) {
+    // Changing the state of |this| now will lead to extra layouts and
+    // paints we don't want, so create another SuggestionView to calculate
+    // which label we have room to show.
+    SuggestionView sizing_view(NULL);
+    sizing_view.SetLabelText(state_.vertically_compact_text);
+    sizing_view.SetIcon(state_.icon);
+    sizing_view.SetTextfield(state_.extra_text, state_.extra_icon);
+
+    // Shortcut |sizing_view|'s GetHeightForWidth() to avoid an infinite loop.
+    // Its BoxLayout must do these calculations for us.
+    views::LayoutManager* layout = sizing_view.GetLayoutManager();
+    if (layout->GetPreferredSize(&sizing_view).width() <= available_width) {
+      calculated_heights_[available_width] = std::make_pair(
+          true,
+          layout->GetPreferredHeightForWidth(&sizing_view, available_width));
+    } else {
+      sizing_view.SetLabelText(state_.horizontally_compact_text);
+      calculated_heights_[available_width] = std::make_pair(
+          false,
+          layout->GetPreferredHeightForWidth(&sizing_view, available_width));
+    }
+  }
+
+  std::pair<bool, int> values = calculated_heights_[available_width];
+  *resulting_height = values.second;
+  return values.first;
+}
+
+void AutofillDialogViews::SuggestionView::OnBoundsChanged(
+    const gfx::Rect& previous_bounds) {
+  int unused;
+  SetLabelText(CanUseVerticallyCompactText(width(), &unused) ?
+      state_.vertically_compact_text :
+      state_.horizontally_compact_text);
+}
+
+void AutofillDialogViews::SuggestionView::SetState(
+    const SuggestionState& state) {
+  calculated_heights_.clear();
+  state_ = state;
+  SetVisible(state_.show);
+  // Set to the more compact text for now. |this| will optionally switch to
+  // the more vertically expanded view when the bounds are set.
+  SetLabelText(state_.vertically_compact_text);
+  SetIcon(state_.icon);
+  SetTextfield(state_.extra_text, state_.extra_icon);
+  PreferredSizeChanged();
+}
+
+void AutofillDialogViews::SuggestionView::SetLabelText(
+    const base::string16& text) {
   // TODO(estade): does this localize well?
   base::string16 line_return(ASCIIToUTF16("\n"));
   size_t position = text.find(line_return);
   if (position == base::string16::npos) {
     label_->SetText(text);
     label_line_2_->SetVisible(false);
   } else {
     label_->SetText(text.substr(0, position));
     label_line_2_->SetText(text.substr(position + line_return.length()));
     label_line_2_->SetVisible(true);
   }
 }
 
-void AutofillDialogViews::SuggestionView::SetSuggestionIcon(
+void AutofillDialogViews::SuggestionView::SetIcon(
     const gfx::Image& image) {
   icon_->SetVisible(!image.IsEmpty());
   icon_->SetImage(image.AsImageSkia());
 }
 
-void AutofillDialogViews::SuggestionView::ShowTextfield(
+void AutofillDialogViews::SuggestionView::SetTextfield(
     const base::string16& placeholder_text,
     const gfx::Image& icon) {
   decorated_->set_placeholder_text(placeholder_text);
   decorated_->SetIcon(icon);
-  decorated_->SetVisible(true);
-  // The textfield will increase the height of the first row and cause the
-  // label to be aligned properly, so the border is not necessary.
-  label_->set_border(NULL);
+  decorated_->SetVisible(!placeholder_text.empty());
 }
 
 // AutofillDialogViews::AutocheckoutStepsArea ---------------------------------
 
 AutofillDialogViews::AutocheckoutStepsArea::AutocheckoutStepsArea() {
   SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical,
                                         kAutocheckoutStepsAreaPadding,
                                         0,
                                         kAutocheckoutStepInset));
 }
@@ skipping 721 matching lines @@
 
 views::View* AutofillDialogViews::CreateInputsContainer(DialogSection section) {
   // The |info_view| holds |manual_inputs| and |suggested_info|, allowing the
   // dialog to toggle which is shown.
   views::View* info_view = new views::View();
   info_view->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
 
   views::View* manual_inputs = InitInputsView(section);
   info_view->AddChildView(manual_inputs);
-  SuggestionView* suggested_info =
-      new SuggestionView(controller_->EditSuggestionText(), this);
+  SuggestionView* suggested_info = new SuggestionView(this);
   info_view->AddChildView(suggested_info);
 
   // TODO(estade): It might be slightly more OO if this button were created
   // and listened to by the section container.
   views::ImageButton* menu_button = new views::ImageButton(this);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   menu_button->SetImage(views::Button::STATE_NORMAL,
       rb.GetImageSkiaNamed(IDR_AUTOFILL_DIALOG_MENU_BUTTON));
   menu_button->SetImage(views::Button::STATE_PRESSED,
       rb.GetImageSkiaNamed(IDR_AUTOFILL_DIALOG_MENU_BUTTON_P));
@@ skipping 135 matching lines @@
       }
     }
   }
 
   UpdateDetailsGroupState(*group);
 }
 
 void AutofillDialogViews::UpdateDetailsGroupState(const DetailsGroup& group) {
   const SuggestionState& suggestion_state =
       controller_->SuggestionStateForSection(group.section);
-  bool show_suggestions = !suggestion_state.text.empty();
-  group.suggested_info->SetVisible(show_suggestions);
-  group.suggested_info->SetSuggestionText(suggestion_state.text,
-                                          suggestion_state.text_style);
-  group.suggested_info->SetSuggestionIcon(suggestion_state.icon);
-
-  if (!suggestion_state.extra_text.empty()) {
-    group.suggested_info->ShowTextfield(
-        suggestion_state.extra_text,
-        suggestion_state.extra_icon);
-  }
-
-  group.manual_input->SetVisible(!show_suggestions);
+  group.suggested_info->SetState(suggestion_state);
+  group.manual_input->SetVisible(!suggestion_state.show);
 
   // Show or hide the "Save in chrome" checkbox. If nothing is in editing mode,
   // hide. If the controller tells us not to show it, likewise hide.
   UpdateSaveInChromeCheckbox();
 
   const bool has_menu = !!controller_->MenuModelForSection(group.section);
 
   if (group.suggested_button)
     group.suggested_button->SetVisible(has_menu);
 
   if (group.container) {
-    group.container->SetForwardMouseEvents(has_menu && show_suggestions);
+    group.container->SetForwardMouseEvents(
+        has_menu && suggestion_state.show);
     group.container->SetVisible(controller_->SectionIsActive(group.section));
     if (group.container->visible())
       ValidateGroup(group, VALIDATE_EDIT);
   }
 
   ContentsPreferredSizeChanged();
 }
 
 template<class T>
 void AutofillDialogViews::SetValidityForInput(
@@ skipping 276 matching lines @@
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill