ash / style / system_dialog_delegate_view.cc [blame]

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/style/system_dialog_delegate_view.h"

#include <memory>

#include "ash/public/cpp/ash_view_ids.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/style/typography.h"
#include "base/functional/bind.h"
#include "ui/aura/window.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/models/image_model.h"
#include "ui/chromeos/styles/cros_tokens_color_mappings.h"
#include "ui/color/color_id.h"
#include "ui/compositor/layer.h"
#include "ui/events/event.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/strings/grit/ui_strings.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/controls/image_view.h"
#include "ui/views/controls/label.h"
#include "ui/views/highlight_border.h"
#include "ui/views/layout/flex_layout.h"
#include "ui/views/layout/flex_layout_types.h"
#include "ui/views/layout/flex_layout_view.h"
#include "ui/views/layout/layout_types.h"
#include "ui/views/view_class_properties.h"
#include "ui/wm/core/window_util.h"

namespace ash {

namespace {

// The default color IDs of the dialog.
constexpr ui::ColorId kBackgroundColorId = cros_tokens::kCrosSysBaseElevated;
constexpr ui::ColorId kBodyColorId = cros_tokens::kCrosSysOnSurfaceVariant;
constexpr ui::ColorId kIconColorId = cros_tokens::kCrosSysPrimary;
constexpr ui::ColorId kTitleColorId = cros_tokens::kCrosSysOnSurface;

// The default layout parameters of the dialog.
constexpr gfx::Size kMinimumDialogSize = gfx::Size(296, 144);
constexpr gfx::Size kMaximumDialogSize = gfx::Size(512, 600);
constexpr int kRoundedCornerRadius = 20;
constexpr gfx::Insets kBorderInsets = gfx::Insets::TLBR(32, 32, 28, 32);
constexpr int kIconSize = 32;
constexpr int kIconBottomPadding = 20;
constexpr int kTitleBottomPadding = 16;
constexpr int kDefaultContentPadding = 32;
constexpr int kButtonContainerTopPadding = 32;
constexpr int kButtonSpacing = 8;
constexpr int kMinimumAdditionalButtonPadding = 80;

// Typical sizes of a dialog.
constexpr int kDialogWidthLarge = 512;
constexpr int kDialogWidthMedium = 359;
constexpr int kDialogWidthSmall = 296;

// The host window sizes that will change the resizing rule of the dialog.
constexpr int kHostWidthLarge = 672;
constexpr int kHostWidthMedium = 520;
constexpr int kHostWidthSmall = 424;
constexpr int kHostWidthXSmall = 400;

// Padding between the dialog and the host window.
constexpr int kDialogHostPaddingLarge = 80;
constexpr int kDialogHostPaddingSmall = 32;

// The default fonts of the title and description.
constexpr TypographyToken kTitleFont = TypographyToken::kCrosDisplay7;
constexpr TypographyToken kBodyFont = TypographyToken::kCrosBody1;

// Sets margins and flex layout specs to the view.
void SetViewLayoutSpecs(
    views::View* view,
    const gfx::Insets& margins = gfx::Insets(),
    const views::FlexSpecification flex_spec = views::FlexSpecification()) {
  view->SetProperty(views::kMarginsKey, margins);
  view->SetProperty(views::kFlexBehaviorKey, flex_spec);
}

// Sets the cross alignment to the given view.
void SetViewCrossAxisAlignment(views::View* view,
                               views::LayoutAlignment alignment) {
  CHECK(view);
  auto* cross_alignment = view->GetProperty(views::kCrossAxisAlignmentKey);
  if (!cross_alignment || *cross_alignment != alignment) {
    view->SetProperty(views::kCrossAxisAlignmentKey, alignment);
  }
}

// Gets the host window of the dialog.
aura::Window* GetDialogHostWindow(const views::Widget* dialog_widget) {
  if (!dialog_widget) {
    return nullptr;
  }

  // Return transient parent as the host window if exists. Otherwise, return the
  // default parent.
  auto* dialog_window = dialog_widget->GetNativeWindow();
  auto* transient_parent = wm::GetTransientParent(dialog_window);
  return transient_parent ? transient_parent : dialog_window->parent();
}

}  // namespace

DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(SystemDialogDelegateView,
                                      kAcceptButtonIdForTesting);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(SystemDialogDelegateView,
                                      kCancelButtonIdForTesting);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(SystemDialogDelegateView,
                                      kDescriptionTextIdForTesting);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(SystemDialogDelegateView,
                                      kTitleTextIdForTesting);

//------------------------------------------------------------------------------
// SystemDialogDelegateView::ButtonContainer:
// The container includes an accept button and a cancel button. The buttons are
// awlays at the right bottom corner of the dialog. The container also allows an
// additional view to be added at the left side. Please refer to the example in
// the header file for the container layout.
class SystemDialogDelegateView::ButtonContainer : public views::FlexLayoutView {
  METADATA_HEADER(ButtonContainer, views::FlexLayoutView)

 public:
  explicit ButtonContainer(SystemDialogDelegateView* dialog_view)
      : cancel_button_(AddChildView(std::make_unique<PillButton>(
            base::BindRepeating(&SystemDialogDelegateView::Cancel,
                                base::Unretained(dialog_view)),
            l10n_util::GetStringUTF16(IDS_APP_CANCEL),
            PillButton::Type::kSecondaryWithoutIcon))),
        accept_button_(AddChildView(std::make_unique<PillButton>(
            base::BindRepeating(&SystemDialogDelegateView::Accept,
                                base::Unretained(dialog_view)),
            l10n_util::GetStringUTF16(IDS_APP_OK),
            PillButton::Type::kPrimaryWithoutIcon))) {
    SetOrientation(views::LayoutOrientation::kHorizontal);
    SetMainAxisAlignment(views::LayoutAlignment::kEnd);
    SetCrossAxisAlignment(views::LayoutAlignment::kCenter);

    SetViewLayoutSpecs(cancel_button_,
                       gfx::Insets::TLBR(0, 0, 0, kButtonSpacing));

    cancel_button_->SetID(
        ViewID::VIEW_ID_STYLE_SYSTEM_DIALOG_DELEGATE_CANCEL_BUTTON);
    cancel_button_->SetProperty(views::kElementIdentifierKey,
                                kCancelButtonIdForTesting);
    cancel_button_->SetBackgroundColorId(cros_tokens::kCrosSysPrimaryContainer);
    cancel_button_->SetButtonTextColorId(
        cros_tokens::kCrosSysOnPrimaryContainer);
    cancel_button_->SetIconColorId(cros_tokens::kCrosSysOnPrimaryContainer);

    accept_button_->SetID(
        ViewID::VIEW_ID_STYLE_SYSTEM_DIALOG_DELEGATE_ACCEPT_BUTTON);
    accept_button_->SetProperty(views::kElementIdentifierKey,
                                kAcceptButtonIdForTesting);
    accept_button_->SetIsDefault(true);
  }

  ButtonContainer(const ButtonContainer&) = delete;
  ButtonContainer& operator=(const ButtonContainer&) = delete;
  ~ButtonContainer() override = default;

  const PillButton* accept_button() const { return accept_button_; }
  PillButton* accept_button() { return accept_button_; }
  const PillButton* cancel_button() const { return cancel_button_; }
  PillButton* cancel_button() { return cancel_button_; }

  void SetAcceptText(const std::u16string& accept_text) {
    accept_button_->SetText(accept_text);
  }

  void SetCancelText(const std::u16string& cancel_text) {
    cancel_button_->SetText(cancel_text);
  }

  void SetAdditionalView(std::unique_ptr<views::View> additional_view) {
    if (additional_view_) {
      RemoveChildViewT(additional_view_);
    }

    // Create a place holder view to fill the space between the cancel button
    // and the additional view.
    if (!place_holder_view_) {
      place_holder_view_ = AddChildViewAt(std::make_unique<views::View>(), 0);
      SetViewLayoutSpecs(
          place_holder_view_,
          gfx::Insets::TLBR(0, 0, 0, kMinimumAdditionalButtonPadding),
          views::FlexSpecification(views::MinimumFlexSizeRule::kPreferred,
                                   views::MaximumFlexSizeRule::kUnbounded));
    }
    additional_view_ = AddChildViewAt(std::move(additional_view), 0);
  }

 private:
  // Owned by the container.
  raw_ptr<PillButton> cancel_button_ = nullptr;
  raw_ptr<PillButton> accept_button_ = nullptr;
  raw_ptr<views::View> additional_view_ = nullptr;
  // The view used to fill the free spaces between the additional view and
  // cancel button.
  raw_ptr<views::View> place_holder_view_ = nullptr;
};

BEGIN_METADATA(SystemDialogDelegateView, ButtonContainer)
END_METADATA

//------------------------------------------------------------------------------
// SystemDialogDelegateView:
SystemDialogDelegateView::SystemDialogDelegateView() {
  // Set border and background.
  SetBorder(views::CreatePaddedBorder(
      std::make_unique<views::HighlightBorder>(
          kRoundedCornerRadius,
          views::HighlightBorder::Type::kHighlightBorderOnShadow),
      kBorderInsets));
  SetBackground(views::CreateThemedRoundedRectBackground(kBackgroundColorId,
                                                         kRoundedCornerRadius));

  // Set shadow.
  shadow_ = SystemShadow::CreateShadowOnNinePatchLayerForView(
      this, SystemShadow::Type::kElevation12);
  shadow_->SetRoundedCornerRadius(kRoundedCornerRadius);

  // Use flex layout.
  SetLayoutManager(std::make_unique<views::FlexLayout>())
      ->SetOrientation(views::LayoutOrientation::kVertical)
      .SetMainAxisAlignment(views::LayoutAlignment::kStart)
      .SetCrossAxisAlignment(views::LayoutAlignment::kStretch)
      .SetCollapseMargins(true);

  icon_ = AddChildView(std::make_unique<views::ImageView>());
  SetViewLayoutSpecs(icon_, gfx::Insets::TLBR(0, 0, kIconBottomPadding, 0));
  icon_->SetProperty(views::kCrossAxisAlignmentKey,
                     views::LayoutAlignment::kStart);
  icon_->SetVisible(false);

  // Configure icon, title, description, and button container with pre-defined
  // layout.
  auto* typography_provider = TypographyProvider::Get();
  title_ = AddChildView(std::make_unique<views::Label>());
  SetViewLayoutSpecs(title_, gfx::Insets::TLBR(0, 0, kTitleBottomPadding, 0));
  typography_provider->StyleLabel(kTitleFont, *title_);
  title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
  title_->SetAutoColorReadabilityEnabled(false);
  title_->SetEnabledColorId(kTitleColorId);
  title_->SetVisible(false);
  title_->GetViewAccessibility().SetRole(ax::mojom::Role::kHeading);
  title_->SetProperty(views::kElementIdentifierKey, kTitleTextIdForTesting);

  description_ = AddChildView(std::make_unique<views::Label>());
  SetViewLayoutSpecs(
      description_, gfx::Insets(),
      views::FlexSpecification(views::LayoutOrientation::kHorizontal,
                               views::MinimumFlexSizeRule::kScaleToMinimum,
                               views::MaximumFlexSizeRule::kUnbounded, true,
                               views::MinimumFlexSizeRule::kPreferred));
  typography_provider->StyleLabel(kBodyFont, *description_);
  description_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
  description_->SetMultiLine(true);
  description_->SetAllowCharacterBreak(true);
  description_->SetAutoColorReadabilityEnabled(false);
  description_->SetEnabledColorId(kBodyColorId);
  description_->SetVisible(false);
  description_->SetProperty(views::kElementIdentifierKey,
                            kDescriptionTextIdForTesting);

  button_container_ = AddChildView(std::make_unique<ButtonContainer>(this));
  SetViewLayoutSpecs(
      button_container_, gfx::Insets::TLBR(kButtonContainerTopPadding, 0, 0, 0),
      views::FlexSpecification(views::LayoutOrientation::kHorizontal,
                               views::MinimumFlexSizeRule::kScaleToMinimum,
                               views::MaximumFlexSizeRule::kUnbounded));

  SetAccessibleWindowRole(ax::mojom::Role::kDialog);
  // Make dialog initially focus on the accept button.
  SetInitiallyFocusedView(button_container_->accept_button());

  // Register the close callback.
  RegisterWindowClosingCallback(
      base::BindOnce(&SystemDialogDelegateView::Close, base::Unretained(this)));
}

SystemDialogDelegateView::~SystemDialogDelegateView() = default;

void SystemDialogDelegateView::SetIcon(const gfx::VectorIcon& icon) {
  icon_->SetImage(
      ui::ImageModel::FromVectorIcon(icon, kIconColorId, kIconSize));
  icon_->SetVisible(true);
}

void SystemDialogDelegateView::SetTitleText(const std::u16string& title) {
  title_->SetText(title);
  title_->SetVisible(!title.empty());
  SetAccessibleTitle(title);
}

void SystemDialogDelegateView::SetDescription(
    const std::u16string& description) {
  description_->SetText(description);
  description_->SetVisible(!description.empty());
}

void SystemDialogDelegateView::SetDescriptionAccessibleName(
    const std::u16string& accessible_name) {
  description_->GetViewAccessibility().SetName(accessible_name);
}

void SystemDialogDelegateView::SetAcceptButtonVisible(bool visible) {
  button_container_->accept_button()->SetVisible(visible);
}

void SystemDialogDelegateView::SetCancelButtonVisible(bool visible) {
  button_container_->cancel_button()->SetVisible(visible);
}

void SystemDialogDelegateView::SetAcceptButtonText(
    const std::u16string& accept_text) {
  button_container_->SetAcceptText(accept_text);
}

void SystemDialogDelegateView::SetCancelButtonText(
    const std::u16string& cancel_text) {
  button_container_->SetCancelText(cancel_text);
}

void SystemDialogDelegateView::SetButtonContainerAlignment(
    views::LayoutAlignment alignment) {
  button_container_->SetMainAxisAlignment(alignment);
}

void SystemDialogDelegateView::SetTopContentAlignment(
    views::LayoutAlignment alignment) {
  SetViewCrossAxisAlignment(contents_[ContentType::kTop], alignment);
}

void SystemDialogDelegateView::SetMiddleContentAlignment(
    views::LayoutAlignment alignment) {
  SetViewCrossAxisAlignment(contents_[ContentType::kMiddle], alignment);
}

void SystemDialogDelegateView::SetTitleMargins(const gfx::Insets& margins) {
  SetViewLayoutSpecs(title_, margins);
}

gfx::Size SystemDialogDelegateView::CalculatePreferredSize(
    const views::SizeBounds& available_size) const {
  auto* host_window = GetDialogHostWindow(GetWidget());
  // If the delegate view is not added to a widget or parented to a host window,
  // return the default preferred size.
  if (!host_window) {
    return views::WidgetDelegateView::CalculatePreferredSize(available_size);
  }

  // Otherwise, calculate the preferred size according to its host window size.
  const int host_width = host_window->GetBoundsInScreen().width();
  // The resizing rules of the dialog are as follows:
  // - When the host window width is larger than `kHostWidthLarge`, the dialog
  // width would remain at `kDialogWidthLarge`.
  // - When the host window width is between `kHostWidthMedium` and
  // `kHostWidthLarge`, the dialog width will decrease but maintain a padding
  // of `kDialogHostPaddingLarge` on both sides.
  // - When the host window width is between `kHostWidthSmall` and
  // `kHostWidthMedium`, the dialog width would remain at `kDialogWidthMedium`.
  // - When the host window width is less than `kHostWidthXSmall`, the dialog
  // width will decrease but maintain a padding of `kDialogHostPaddingSmall` on
  // both sides.
  // - The dialog minimum width is `kDialogWidthSmall`.
  int dialog_width = kDialogWidthSmall;
  if (host_width >= kHostWidthLarge) {
    dialog_width = kDialogWidthLarge;
  } else if (host_width >= kHostWidthMedium) {
    dialog_width = host_width - kDialogHostPaddingLarge * 2;
  } else if (host_width >= kHostWidthSmall) {
    dialog_width = kDialogWidthMedium;
  } else if (host_width >= kHostWidthXSmall) {
    dialog_width = host_width - kDialogHostPaddingSmall * 2;
  }

  return gfx::Size(dialog_width, GetLayoutManager()->GetPreferredHeightForWidth(
                                     this, dialog_width));
}

gfx::Size SystemDialogDelegateView::GetMinimumSize() const {
  return kMinimumDialogSize;
}

gfx::Size SystemDialogDelegateView::GetMaximumSize() const {
  return kMaximumDialogSize;
}

void SystemDialogDelegateView::OnWidgetInitialized() {
  UpdateDialogSize();
}

void SystemDialogDelegateView::OnWorkAreaChanged() {
  UpdateDialogSize();
}

const PillButton* SystemDialogDelegateView::GetAcceptButtonForTesting() const {
  return button_container_->accept_button();
}

const PillButton* SystemDialogDelegateView::GetCancelButtonForTesting() const {
  return button_container_->cancel_button();
}

void SystemDialogDelegateView::UpdateDialogSize() {
  if (auto* widget = GetWidget()) {
    widget->CenterWindow(GetPreferredSize());
  }
}

size_t SystemDialogDelegateView::GetContentIndex(ContentType type) const {
  switch (type) {
    case ContentType::kTop:
      return 0u;
    case ContentType::kMiddle:
      // The middle content is right after the description.
      return GetIndexOf(description_).value() + 1u;
  }
}

void SystemDialogDelegateView::SetContentInternal(
    std::unique_ptr<views::View> view,
    ContentType type) {
  // If there is an existing content, remove it.
  views::View* content = contents_[type];
  if (content) {
    contents_[type] = nullptr;
    RemoveChildViewT(content);
  }

  // Add content and move it to the specific position.
  content = AddChildViewAt(std::move(view), GetContentIndex(type));

  // Set default bottom/top margins to the top/middle content if there is no
  // preset margins or the corresponding margins are 0.
  auto* margins = content->GetProperty(views::kMarginsKey);
  switch (type) {
    case ContentType::kTop:
      if (!margins) {
        content->SetProperty(
            views::kMarginsKey,
            gfx::Insets::TLBR(0, 0, kDefaultContentPadding, 0));
      } else if (!margins->bottom()) {
        margins->set_bottom(kDefaultContentPadding);
      }
      break;
    case ContentType::kMiddle:
      if (!margins) {
        content->SetProperty(
            views::kMarginsKey,
            gfx::Insets::TLBR(kDefaultContentPadding, 0, 0, 0));
      } else if (!margins->top()) {
        margins->set_top(kDefaultContentPadding);
      }
      break;
  }
  content->SetProperty(views::kCrossAxisAlignmentKey,
                       views::LayoutAlignment::kCenter);
  contents_[type] = content;
}

void SystemDialogDelegateView::SetAdditionalViewInButtonRowInternal(
    std::unique_ptr<views::View> view) {
  button_container_->SetAdditionalView(std::move(view));
}

void SystemDialogDelegateView::Accept() {
  if (!closing_dialog_) {
    RunCallbackAndCloseDialog(
        std::move(accept_callback_),
        views::Widget::ClosedReason::kAcceptButtonClicked);
  }
}

void SystemDialogDelegateView::Cancel() {
  if (!closing_dialog_) {
    RunCallbackAndCloseDialog(
        std::move(cancel_callback_),
        views::Widget::ClosedReason::kCancelButtonClicked);
  }
}

void SystemDialogDelegateView::Close() {
  if (!closing_dialog_ && close_callback_) {
    std::move(close_callback_).Run();
  }
  closing_dialog_ = true;
}

void SystemDialogDelegateView::RunCallbackAndCloseDialog(
    base::OnceClosure callback,
    views::Widget::ClosedReason closed_reason) {
  CHECK(!closing_dialog_);

  if (callback) {
    std::move(callback).Run();
  }

  if (auto* widget = GetWidget()) {
    // Update the `closing_dialog_` before closing the widget.
    closing_dialog_ = true;
    widget->CloseWithReason(closed_reason);
  }
}

BEGIN_METADATA(SystemDialogDelegateView)
END_METADATA

}  // namespace ash