Allow dialogs to use a custom View as their title.

ui/views/bubble/bubble_frame_view.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/bubble/bubble_frame_view.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "build/build_config.h"
 #include "ui/base/default_style.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/vector_icons/vector_icons.h"
 #include "ui/views/bubble/bubble_border.h"
+#include "ui/views/bubble/bubble_dialog_delegate.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/image_button_factory.h"
 #include "ui/views/controls/image_view.h"
-#include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/layout_provider.h"
 #include "ui/views/resources/grit/views_resources.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/client_view.h"
 #include "ui/views/window/dialog_delegate.h"
 
 namespace views {
 
@@ skipping 32 matching lines @@
 
 // static
 const char BubbleFrameView::kViewClassName[] = "BubbleFrameView";
 
 BubbleFrameView::BubbleFrameView(const gfx::Insets& title_margins,
                                  const gfx::Insets& content_margins)
     : bubble_border_(nullptr),
       title_margins_(title_margins),
       content_margins_(content_margins),
       title_icon_(new views::ImageView()),
-      title_(nullptr),
+      default_title_(CreateDefaultTitleLabel(base::string16()).release()),
+      custom_title_(nullptr),
       close_(nullptr),
       footnote_container_(nullptr),
       close_button_clicked_(false) {
   AddChildView(title_icon_);
 
-  title_ = new Label(base::string16(), style::CONTEXT_DIALOG_TITLE);
-  title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  title_->set_collapse_when_hidden(true);
-  title_->SetVisible(false);
-  title_->SetMultiLine(true);
-  AddChildView(title_);
+  default_title_->SetVisible(false);
+  AddChildView(default_title_);
 
   close_ = CreateCloseButton(this);
   close_->SetVisible(false);
 #if defined(OS_WIN)
   // Windows will automatically create a tooltip for the close button based on
   // the HTCLOSE result from NonClientHitTest().
   close_->SetTooltipText(base::string16());
 #endif
   AddChildView(close_);
 }
 
 BubbleFrameView::~BubbleFrameView() {}
 
 // static
+std::unique_ptr<Label> BubbleFrameView::CreateDefaultTitleLabel(
+    const base::string16& title_text) {
+  auto title = base::MakeUnique<Label>(title_text, style::CONTEXT_DIALOG_TITLE);
+  title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  title->set_collapse_when_hidden(true);
+  title->SetMultiLine(true);
+  return title;
+}
+
+// static
 Button* BubbleFrameView::CreateCloseButton(ButtonListener* listener) {
   ImageButton* close_button = nullptr;
   if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
     close_button = CreateVectorImageButton(listener);
     SetImageFromVectorIcon(close_button, ui::kCloseIcon);
   } else {
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     close_button = new ImageButton(listener);
     close_button->SetImage(CustomButton::STATE_NORMAL,
                            *rb->GetImageNamed(IDR_CLOSE_DIALOG).ToImageSkia());
@@ skipping 47 matching lines @@
 
   // Allow dialogs to show the system menu and be dragged.
   if (GetWidget()->widget_delegate()->AsDialogDelegate() &&
       !GetWidget()->widget_delegate()->AsBubbleDialogDelegate()) {
     gfx::Rect bounds(GetContentsBounds());
     bounds.Inset(title_margins_);
     gfx::Rect sys_rect(0, 0, bounds.x(), bounds.y());
     sys_rect.set_origin(gfx::Point(GetMirroredXForRect(sys_rect), 0));
     if (sys_rect.Contains(point))
       return HTSYSMENU;
-    if (point.y() < title_->bounds().bottom())
+    if (point.y() < title()->bounds().bottom())
       return HTCAPTION;
   }
 
   return GetWidget()->client_view()->NonClientHitTest(point);
 }
 
 void BubbleFrameView::GetWindowMask(const gfx::Size& size,
                                     gfx::Path* window_mask) {
   if (bubble_border_->shadow() != BubbleBorder::SMALL_SHADOW &&
       bubble_border_->shadow() != BubbleBorder::NO_SHADOW_OPAQUE_BORDER &&
@@ skipping 38 matching lines @@
 }
 
 void BubbleFrameView::UpdateWindowIcon() {
   gfx::ImageSkia image;
   if (GetWidget()->widget_delegate()->ShouldShowWindowIcon())
     image = GetWidget()->widget_delegate()->GetWindowIcon();
   title_icon_->SetImage(&image);
 }
 
 void BubbleFrameView::UpdateWindowTitle() {
-  title_->SetText(GetWidget()->widget_delegate()->GetWindowTitle());
-  title_->SetVisible(GetWidget()->widget_delegate()->ShouldShowWindowTitle());
+  if (default_title_) {
+    const WidgetDelegate* delegate = GetWidget()->widget_delegate();
+    default_title_->SetVisible(delegate->ShouldShowWindowTitle());
+    default_title_->SetText(delegate->GetWindowTitle());
+  }  // custom_title_'s updates are handled by its creator.
 }
 
 void BubbleFrameView::SizeConstraintsChanged() {}
 
-void BubbleFrameView::SetTitleFontList(const gfx::FontList& font_list) {
-  title_->SetFontList(font_list);
+void BubbleFrameView::SetTitleView(View* title_view) {
+  DCHECK(title_view);
+  delete default_title_;
+  default_title_ = nullptr;
+  delete custom_title_;
+  custom_title_ = title_view;
+  // Keep the title after the icon for focus order.
+  AddChildViewAt(custom_title_, 1);
 }
 
 const char* BubbleFrameView::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Insets BubbleFrameView::GetInsets() const {
   gfx::Insets insets = content_margins_;
 
   const int icon_height = title_icon_->GetPreferredSize().height();
-  const int label_height = title_->GetPreferredSize().height();
+  const int label_height = title()->GetPreferredSize().height();
   const bool has_title = icon_height > 0 || label_height > 0;
   const int title_padding = has_title ? title_margins_.height() : 0;
   const int title_height = std::max(icon_height, label_height) + title_padding;
   const int close_height =
       GetWidget()->widget_delegate()->ShouldShowCloseButton()
           ? close_->height() + LayoutProvider::Get()->GetDistanceMetric(
                                    DISTANCE_CLOSE_BUTTON_MARGIN)
           : 0;
   insets += gfx::Insets(std::max(title_height, close_height), 0, 0, 0);
   return insets;
@@ skipping 32 matching lines @@
 #endif  // OS_MACOSX
   // Non-dialog bubbles should be non-resizable, so its max size is its
   // preferred size.
   return GetPreferredSize();
 #endif
 }
 
 void BubbleFrameView::Layout() {
   // The title margins may not be set, but make sure that's only the case when
   // there's no title.
-  DCHECK(!title_margins_.IsEmpty() || !title_->visible());
+  DCHECK(!title_margins_.IsEmpty() ||
+         (!custom_title_ && !default_title_->visible()));
 
   const gfx::Rect contents_bounds = GetContentsBounds();
   gfx::Rect bounds = contents_bounds;
   bounds.Inset(title_margins_);
   if (bounds.IsEmpty())
     return;
 
-  // The close button is positioned somewhat closer to the edge of the bubble.
-  const int close_margin =
-      LayoutProvider::Get()->GetDistanceMetric(DISTANCE_CLOSE_BUTTON_MARGIN);
-  close_->SetPosition(
-      gfx::Point(contents_bounds.right() - close_margin - close_->width(),
-                 contents_bounds.y() + close_margin));
+  int title_label_right = bounds.right();
+  if (close_->visible()) {
+    // The close button is positioned somewhat closer to the edge of the bubble.
+    const int close_margin =
+        LayoutProvider::Get()->GetDistanceMetric(DISTANCE_CLOSE_BUTTON_MARGIN);
+    close_->SetPosition(
+        gfx::Point(contents_bounds.right() - close_margin - close_->width(),
+                   contents_bounds.y() + close_margin));
+    title_label_right = close_->x() - close_margin;

[Peter Kasting, 2017/06/23 06:00:09]

As I tried to convey in email, I think this would be theoretically safer:

    title_label_right = std::min(title_label_right, close_->x() - close_margin);

This way if for some reason we set really enormous title margins, adding a close
button in the corner wouldn't suddenly reduce them.

This seems unlikely, but assuming things = three years from now Harmony phase 57
breaks :)

[Bret, 2017/06/24 01:12:33]

Done.

+  }
 
   gfx::Size title_icon_pref_size(title_icon_->GetPreferredSize());
-  int padding = 0;
-  int title_height = title_icon_pref_size.height();
-
-  if (title_->visible() && !title_->text().empty()) {
-    if (title_icon_pref_size.width() > 0)
-      padding = title_margins_.left();
-
-    const int title_label_x =
-        bounds.x() + title_icon_pref_size.width() + padding;
-    title_->SizeToFit(std::max(1, close_->x() - title_label_x));
-    title_height = std::max(title_height, title_->height());
-    title_->SetPosition(gfx::Point(
-        title_label_x, bounds.y() + (title_height - title_->height()) / 2));
-  }
+  const int title_icon_padding =
+      title_icon_pref_size.width() > 0 ? title_margins_.left() : 0;
+  const int title_label_x =
+      bounds.x() + title_icon_pref_size.width() + title_icon_padding;
+  const int title_available_width =
+      std::max(1, title_label_right - title_label_x);
+  const int title_preferred_height =
+      title()->GetHeightForWidth(title_available_width);
+  const int title_height =
+      std::max(title_icon_pref_size.height(), title_preferred_height);
+  title()->SetBounds(title_label_x,
+                     bounds.y() + (title_height - title_preferred_height) / 2,
+                     title_available_width, title_height);
 
   title_icon_->SetBounds(bounds.x(), bounds.y(), title_icon_pref_size.width(),
                          title_height);
-  bounds.set_width(title_->bounds().right() - bounds.x());
-  bounds.set_height(title_height);
 
   if (footnote_container_) {
     const int width = contents_bounds.width();
     const int height = footnote_container_->GetHeightForWidth(width);
     footnote_container_->SetBounds(
         contents_bounds.x(), contents_bounds.bottom() - height, width, height);
   }
 }
 
 void BubbleFrameView::OnThemeChanged() {
@@ skipping 170 matching lines @@
       bubble_border_->GetArrowOffset(window_bounds.size()) - offscreen_adjust);
   if (offscreen_adjust)
     SchedulePaint();
 }
 
 gfx::Size BubbleFrameView::GetSizeForClientSize(
     const gfx::Size& client_size) const {
   // Accommodate the width of the title bar elements.
   int title_bar_width = title_margins_.width() + border()->GetInsets().width();
   gfx::Size title_icon_size = title_icon_->GetPreferredSize();
-  gfx::Size title_label_size = title_->GetPreferredSize();
+  gfx::Size title_label_size = title()->GetPreferredSize();
   if (title_icon_size.width() > 0 && title_label_size.width() > 0)
     title_bar_width += title_margins_.left();
   title_bar_width += title_icon_size.width();
   if (close_->visible())
     title_bar_width += close_->width() + 1;
 
   gfx::Size size(client_size);
   gfx::Insets client_insets = GetInsets();
   size.Enlarge(client_insets.width(), client_insets.height());
   size.SetToMax(gfx::Size(title_bar_width, 0));
 
   if (footnote_container_)
     size.Enlarge(0, footnote_container_->GetHeightForWidth(size.width()));
 
   DialogDelegate* dialog_delegate =
       GetWidget()->widget_delegate()->AsDialogDelegate();
   if (dialog_delegate && dialog_delegate->ShouldSnapFrameWidth())
     size.set_width(LayoutProvider::Get()->GetSnappedDialogWidth(size.width()));
 
   return size;
 }
 
 }  // namespace views