| // Copyright 2020 The Chromium Authors |
| // 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_dialog_model_host.h" |
| |
| #include <utility> |
| |
| #include "base/memory/raw_ptr.h" |
| #include "ui/accessibility/ax_enums.mojom.h" |
| #include "ui/base/class_property.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/base/metadata/metadata_header_macros.h" |
| #include "ui/base/metadata/metadata_impl_macros.h" |
| #include "ui/base/models/combobox_model.h" |
| #include "ui/base/models/dialog_model.h" |
| #include "ui/base/models/dialog_model_field.h" |
| #include "ui/base/models/simple_combobox_model.h" |
| #include "ui/base/mojom/dialog_button.mojom.h" |
| #include "ui/base/mojom/ui_base_types.mojom-shared.h" |
| #include "ui/base/ui_base_types.h" |
| #include "ui/gfx/color_utils.h" |
| #include "ui/gfx/geometry/insets.h" |
| #include "ui/strings/grit/ui_strings.h" |
| #include "ui/views/accessibility/view_accessibility.h" |
| #include "ui/views/border.h" |
| #include "ui/views/bubble/bubble_dialog_delegate_view.h" |
| #include "ui/views/bubble/bubble_dialog_utils.h" |
| #include "ui/views/controls/button/checkbox.h" |
| #include "ui/views/controls/button/label_button_border.h" |
| #include "ui/views/controls/button/md_text_button.h" |
| #include "ui/views/controls/combobox/combobox.h" |
| #include "ui/views/controls/editable_combobox/editable_password_combobox.h" |
| #include "ui/views/controls/label.h" |
| #include "ui/views/controls/scroll_view.h" |
| #include "ui/views/controls/separator.h" |
| #include "ui/views/controls/styled_label.h" |
| #include "ui/views/controls/textfield/textfield.h" |
| #include "ui/views/controls/theme_tracking_image_view.h" |
| #include "ui/views/layout/box_layout.h" |
| #include "ui/views/layout/box_layout_view.h" |
| #include "ui/views/layout/fill_layout.h" |
| #include "ui/views/layout/layout_provider.h" |
| #include "ui/views/style/typography.h" |
| #include "ui/views/view_class_properties.h" |
| |
| namespace views { |
| namespace { |
| |
| // Extra margin to be added to contents view when it's inside a scroll view. |
| constexpr int kScrollViewVerticalMargin = 2; |
| |
| BubbleDialogModelHost::FieldType GetFieldTypeForField( |
| ui::DialogModelField* field) { |
| DCHECK(field); |
| switch (field->type()) { |
| case ui::DialogModelField::kParagraph: |
| return BubbleDialogModelHost::FieldType::kText; |
| case ui::DialogModelField::kCheckbox: |
| return BubbleDialogModelHost::FieldType::kControl; |
| case ui::DialogModelField::kTextfield: |
| return BubbleDialogModelHost::FieldType::kControl; |
| case ui::DialogModelField::kPasswordField: |
| return BubbleDialogModelHost::FieldType::kControl; |
| case ui::DialogModelField::kCombobox: |
| return BubbleDialogModelHost::FieldType::kControl; |
| case ui::DialogModelField::kMenuItem: |
| return BubbleDialogModelHost::FieldType::kMenuItem; |
| case ui::DialogModelField::kTitleItem: |
| // No need to handle titles. |
| NOTREACHED(); |
| case ui::DialogModelField::kSection: |
| // TODO(pbos): Handle nested/multiple sections. |
| NOTREACHED(); |
| case ui::DialogModelField::kSeparator: |
| return BubbleDialogModelHost::FieldType::kMenuItem; |
| case ui::DialogModelField::kCustom: |
| return static_cast<BubbleDialogModelHost::CustomView*>( |
| field->AsCustomField()->field()) |
| ->field_type(); |
| } |
| } |
| |
| int GetFieldTopMargin(LayoutProvider* layout_provider, |
| const BubbleDialogModelHost::FieldType& field_type, |
| const BubbleDialogModelHost::FieldType& last_field_type) { |
| // Menu item preceded by non-menu item should have margin |
| if (field_type == BubbleDialogModelHost::FieldType::kMenuItem && |
| last_field_type == BubbleDialogModelHost::FieldType::kMenuItem) { |
| return 0; |
| } |
| const bool is_control_list = |
| field_type == BubbleDialogModelHost::FieldType::kControl && |
| last_field_type == BubbleDialogModelHost::FieldType::kControl; |
| return layout_provider->GetDistanceMetric( |
| is_control_list ? DISTANCE_CONTROL_LIST_VERTICAL |
| : DISTANCE_UNRELATED_CONTROL_VERTICAL); |
| } |
| |
| int GetDialogTopMargins(LayoutProvider* layout_provider, |
| ui::DialogModelField* first_field) { |
| CHECK(first_field); |
| |
| const BubbleDialogModelHost::FieldType field_type = |
| GetFieldTypeForField(first_field); |
| switch (field_type) { |
| case BubbleDialogModelHost::FieldType::kMenuItem: |
| return 0; |
| case BubbleDialogModelHost::FieldType::kControl: |
| return layout_provider->GetDistanceMetric( |
| DISTANCE_DIALOG_CONTENT_MARGIN_TOP_CONTROL); |
| case BubbleDialogModelHost::FieldType::kText: |
| return layout_provider->GetDistanceMetric( |
| DISTANCE_DIALOG_CONTENT_MARGIN_TOP_TEXT); |
| } |
| } |
| |
| int GetDialogBottomMargins(LayoutProvider* layout_provider, |
| ui::DialogModelField* last_field, |
| bool has_buttons) { |
| CHECK(last_field); |
| const BubbleDialogModelHost::FieldType field_type = |
| GetFieldTypeForField(last_field); |
| switch (field_type) { |
| case BubbleDialogModelHost::FieldType::kMenuItem: |
| return has_buttons ? layout_provider->GetDistanceMetric( |
| DISTANCE_DIALOG_CONTENT_MARGIN_BOTTOM_CONTROL) |
| : 0; |
| case BubbleDialogModelHost::FieldType::kControl: |
| return layout_provider->GetDistanceMetric( |
| DISTANCE_DIALOG_CONTENT_MARGIN_BOTTOM_CONTROL); |
| case BubbleDialogModelHost::FieldType::kText: |
| return layout_provider->GetDistanceMetric( |
| DISTANCE_DIALOG_CONTENT_MARGIN_BOTTOM_TEXT); |
| } |
| } |
| |
| // A subclass of Checkbox that allows using an external Label/StyledLabel view |
| // instead of LabelButton's internal label. This is required for the |
| // Label/StyledLabel to be clickable, while supporting Links which requires a |
| // StyledLabel. |
| class CheckboxControl : public Checkbox { |
| METADATA_HEADER(CheckboxControl, Checkbox) |
| |
| public: |
| CheckboxControl(std::unique_ptr<View> label, int label_line_height) |
| : label_line_height_(label_line_height) { |
| auto* layout = SetLayoutManager(std::make_unique<BoxLayout>()); |
| layout->set_between_child_spacing(LayoutProvider::Get()->GetDistanceMetric( |
| DISTANCE_RELATED_LABEL_HORIZONTAL)); |
| layout->set_cross_axis_alignment(BoxLayout::CrossAxisAlignment::kStart); |
| |
| // TODO(accessibility): There is no `SetAccessibilityProperties` which takes |
| // a labelling view to set the accessible name. |
| GetViewAccessibility().SetName(*label.get()); |
| |
| AddChildView(std::move(label)); |
| } |
| |
| gfx::Size CalculatePreferredSize( |
| const SizeBounds& available_size) const override { |
| // Skip LabelButton to use LayoutManager. |
| return View::CalculatePreferredSize(available_size); |
| } |
| |
| void OnThemeChanged() override { |
| Checkbox::OnThemeChanged(); |
| // This offsets the image to align with the first line of text. See |
| // LabelButton::Layout(). |
| image_container_view()->SetBorder(CreateEmptyBorder(gfx::Insets::TLBR( |
| (label_line_height_ - |
| image_container_view()->GetPreferredSize({}).height()) / |
| 2, |
| 0, 0, 0))); |
| } |
| |
| const int label_line_height_; |
| }; |
| |
| BEGIN_METADATA(CheckboxControl) |
| END_METADATA |
| |
| struct DialogModelHostField { |
| raw_ptr<ui::DialogModelField> dialog_model_field = nullptr; |
| |
| // View representing the entire field. |
| raw_ptr<View> field_view = nullptr; |
| |
| // Child view to |field_view|, if any, that's used for focus. For instance, |
| // a textfield row would be a container that contains both a |
| // views::Textfield and a descriptive label. In this case |focusable_view| |
| // would refer to the views::Textfield which is also what would gain focus. |
| raw_ptr<View> focusable_view = nullptr; |
| }; |
| |
| View* GetTargetView(const DialogModelHostField& field_view_info) { |
| return field_view_info.focusable_view ? field_view_info.focusable_view.get() |
| : field_view_info.field_view.get(); |
| } |
| |
| // TODO(pbos): Consider externalizing this functionality into a different |
| // format that could feasibly be adopted by LayoutManagers. This is used for |
| // BoxLayouts (but could be others) to agree on columns' preferred width as a |
| // replacement for using GridLayout. |
| class LayoutConsensusGroup { |
| public: |
| LayoutConsensusGroup() = default; |
| ~LayoutConsensusGroup() { DCHECK(children_.empty()); } |
| |
| void AddView(View* view) { |
| children_.insert(view); |
| // Because this may change the max preferred/min size, invalidate all child |
| // layouts. |
| for (View* child : children_) { |
| child->InvalidateLayout(); |
| } |
| } |
| |
| void RemoveView(View* view) { children_.erase(view); } |
| |
| // Get the union of all preferred sizes within the group. |
| gfx::Size GetMaxPreferredSize(const SizeBounds& available_size) const { |
| gfx::Size size; |
| for (View* child : children_) { |
| DCHECK_EQ(1u, child->children().size()); |
| size.SetToMax( |
| child->children().front()->GetPreferredSize(available_size)); |
| } |
| return size; |
| } |
| |
| // Get the union of all minimum sizes within the group. |
| gfx::Size GetMaxMinimumSize() const { |
| gfx::Size size; |
| for (View* child : children_) { |
| DCHECK_EQ(1u, child->children().size()); |
| size.SetToMax(child->children().front()->GetMinimumSize()); |
| } |
| return size; |
| } |
| |
| private: |
| base::flat_set<raw_ptr<View, CtnExperimental>> children_; |
| }; |
| |
| class LayoutConsensusView : public View { |
| METADATA_HEADER(LayoutConsensusView, View) |
| |
| public: |
| LayoutConsensusView(LayoutConsensusGroup* group, std::unique_ptr<View> view) |
| : group_(group) { |
| group->AddView(this); |
| SetLayoutManager(std::make_unique<FillLayout>()); |
| AddChildView(std::move(view)); |
| } |
| |
| ~LayoutConsensusView() override { group_->RemoveView(this); } |
| |
| gfx::Size CalculatePreferredSize( |
| const SizeBounds& available_size) const override { |
| const gfx::Size group_preferred_size = |
| group_->GetMaxPreferredSize(available_size); |
| DCHECK_EQ(1u, children().size()); |
| const gfx::Size child_preferred_size = |
| children()[0]->GetPreferredSize(available_size); |
| // TODO(pbos): This uses the max width, but could be configurable to use |
| // either direction. |
| return gfx::Size(group_preferred_size.width(), |
| child_preferred_size.height()); |
| } |
| |
| gfx::Size GetMinimumSize() const override { |
| const gfx::Size group_minimum_size = group_->GetMaxMinimumSize(); |
| DCHECK_EQ(1u, children().size()); |
| const gfx::Size child_minimum_size = children()[0]->GetMinimumSize(); |
| // TODO(pbos): This uses the max width, but could be configurable to use |
| // either direction. |
| return gfx::Size(group_minimum_size.width(), child_minimum_size.height()); |
| } |
| |
| private: |
| const raw_ptr<LayoutConsensusGroup> group_; |
| }; |
| |
| BEGIN_METADATA(LayoutConsensusView) |
| END_METADATA |
| |
| } // namespace |
| |
| BubbleDialogModelHost::CustomView::CustomView(std::unique_ptr<View> view, |
| FieldType field_type, |
| View* focusable_view) |
| : view_(std::move(view)), |
| field_type_(field_type), |
| focusable_view_(focusable_view) {} |
| |
| BubbleDialogModelHost::CustomView::~CustomView() = default; |
| |
| std::unique_ptr<View> BubbleDialogModelHost::CustomView::TransferView() { |
| DCHECK(view_); |
| return std::move(view_); |
| } |
| |
| class BubbleDialogModelHostContentsView final : public DialogModelSectionHost { |
| METADATA_HEADER(BubbleDialogModelHostContentsView, DialogModelSectionHost) |
| |
| public: |
| // TODO(pbos): Break this dependency on BubbleDialogModelHost once most of |
| // OnFieldAdded etc. has moved into this class. |
| BubbleDialogModelHostContentsView( |
| ui::DialogModelSection* contents, |
| ui::ElementIdentifier initially_focused_field_id) |
| : contents_(contents), |
| initially_focused_field_id_(initially_focused_field_id), |
| on_field_added_subscription_( |
| contents->AddOnFieldAddedCallback(base::BindRepeating( |
| &BubbleDialogModelHostContentsView::OnFieldAdded, |
| base::Unretained(this)))), |
| on_field_changed_subscription_( |
| contents->AddOnFieldChangedCallback(base::BindRepeating( |
| &BubbleDialogModelHostContentsView::OnFieldChanged, |
| base::Unretained(this)))) { |
| // Note that between-child spacing is manually handled using kMarginsKey. |
| SetOrientation(views::BoxLayout::Orientation::kVertical); |
| |
| // Add all fields from the model. |
| for (const auto& field : contents_->fields()) { |
| OnFieldAdded(field.get()); |
| } |
| } |
| |
| [[nodiscard]] base::CallbackListSubscription AddOnContentsChangedCallback( |
| base::RepeatingClosure on_contents_changed) { |
| return on_contents_changed_.Add(std::move(on_contents_changed)); |
| } |
| |
| // TODO(pbos): Move (most) of the host's OnFieldAdded stuff into here. If |
| // anything remains try to have BubbleDialogModelHost observe it directly. |
| void OnFieldAdded(ui::DialogModelField* field) { |
| switch (field->type()) { |
| case ui::DialogModelField::kParagraph: |
| AddOrUpdateParagraph(field->AsParagraph()); |
| break; |
| case ui::DialogModelField::kCheckbox: |
| AddOrUpdateCheckbox(field->AsCheckbox()); |
| break; |
| case ui::DialogModelField::kCombobox: |
| AddOrUpdateCombobox(field->AsCombobox()); |
| break; |
| case ui::DialogModelField::kMenuItem: |
| AddOrUpdateMenuItem(field->AsMenuItem()); |
| break; |
| case ui::DialogModelField::kTitleItem: |
| // No need to handle titles. |
| NOTREACHED(); |
| case ui::DialogModelField::kSection: |
| // TODO(pbos): Handle nested/multiple sections. |
| NOTREACHED(); |
| case ui::DialogModelField::kSeparator: |
| AddOrUpdateSeparator(field); |
| break; |
| case ui::DialogModelField::kTextfield: |
| AddOrUpdateTextfield(field->AsTextfield()); |
| break; |
| case ui::DialogModelField::kPasswordField: |
| AddOrUpdatePasswordField(field->AsPasswordField()); |
| break; |
| case ui::DialogModelField::kCustom: |
| AddOrUpdateCustomField(field->AsCustomField()); |
| break; |
| } |
| OnFieldChanged(field); |
| } |
| |
| void OnFieldChanged(ui::DialogModelField* field) { |
| const DialogModelHostField host_field = FindDialogModelHostField(field); |
| |
| if (host_field.field_view) { |
| host_field.field_view->SetVisible(field->is_visible()); |
| } |
| on_contents_changed_.Notify(); |
| } |
| |
| // TODO(pbos): Remove the need for this method by making sure the host always |
| // outlives us. Currently we do outlive them. Widget, WidgetDelegate and |
| // RootView lifetimes are complicated. |
| void Detach() { |
| fields_.clear(); |
| RemoveAllChildViews(); |
| contents_ = nullptr; |
| } |
| |
| void AddOrUpdateParagraph(ui::DialogModelParagraph* model_field) { |
| // TODO(pbos): Handle updating existing field. |
| |
| std::unique_ptr<View> view = |
| model_field->header().empty() |
| ? CreateViewForLabel(model_field->label()) |
| : CreateViewForParagraphWithHeader(model_field->label(), |
| model_field->header()); |
| DialogModelHostField info{model_field, view.get(), nullptr}; |
| view->SetProperty(kElementIdentifierKey, model_field->id()); |
| AddDialogModelHostField(std::move(view), info); |
| } |
| |
| void AddOrUpdateCheckbox(ui::DialogModelCheckbox* model_field) { |
| // TODO(pbos): Handle updating existing field. |
| |
| std::unique_ptr<CheckboxControl> checkbox; |
| if (DialogModelLabelRequiresStyledLabel(model_field->label())) { |
| auto label = CreateStyledLabelForDialogModelLabel(model_field->label()); |
| const int line_height = label->GetLineHeight(); |
| checkbox = |
| std::make_unique<CheckboxControl>(std::move(label), line_height); |
| } else { |
| auto label = CreateLabelForDialogModelLabel(model_field->label()); |
| const int line_height = label->GetLineHeight(); |
| checkbox = |
| std::make_unique<CheckboxControl>(std::move(label), line_height); |
| } |
| checkbox->SetChecked(model_field->is_checked()); |
| |
| checkbox->SetCallback(base::BindRepeating( |
| [](ui::DialogModelCheckbox* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, Checkbox* checkbox, |
| const ui::Event& event) { |
| model_field->OnChecked(pass_key, checkbox->GetChecked()); |
| }, |
| model_field, GetPassKey(), checkbox.get())); |
| |
| DialogModelHostField info{model_field, checkbox.get(), nullptr}; |
| AddDialogModelHostField(std::move(checkbox), info); |
| } |
| void AddOrUpdateCombobox(ui::DialogModelCombobox* model_field) { |
| // TODO(pbos): Handle updating existing field. |
| |
| auto combobox = std::make_unique<Combobox>(model_field->combobox_model()); |
| combobox->GetViewAccessibility().SetName( |
| model_field->accessible_name().empty() |
| ? model_field->label() |
| : model_field->accessible_name()); |
| combobox->SetCallback(base::BindRepeating( |
| [](ui::DialogModelCombobox* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, |
| Combobox* combobox) { model_field->OnPerformAction(pass_key); }, |
| model_field, GetPassKey(), combobox.get())); |
| |
| combobox->SetSelectedIndex(model_field->selected_index()); |
| property_changed_subscriptions_.push_back( |
| combobox->AddSelectedIndexChangedCallback(base::BindRepeating( |
| [](ui::DialogModelCombobox* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, |
| Combobox* combobox) { |
| model_field->OnSelectedIndexChanged( |
| pass_key, combobox->GetSelectedIndex().value()); |
| }, |
| model_field, GetPassKey(), combobox.get()))); |
| AddViewForLabelAndField(model_field, model_field->label(), |
| std::move(combobox)); |
| } |
| |
| void AddOrUpdateMenuItem(ui::DialogModelMenuItem* model_field) { |
| // TODO(pbos): Handle updating existing field. |
| |
| // TODO(crbug.com/40224983): Implement this for enabled items. Sorry! |
| DCHECK(!model_field->is_enabled()); |
| |
| auto item = std::make_unique<LabelButton>( |
| base::BindRepeating( |
| [](ui::DialogModelMenuItem* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, |
| const ui::Event& event) { |
| model_field->OnActivated(pass_key, event.flags()); |
| }, |
| model_field, GetPassKey()), |
| model_field->label()); |
| item->SetImageModel(Button::STATE_NORMAL, model_field->icon()); |
| const auto* const layout_provider = LayoutProvider::Get(); |
| item->SetBorder(views::CreateEmptyBorder(gfx::Insets::VH( |
| layout_provider->GetDistanceMetric(DISTANCE_CONTROL_LIST_VERTICAL) / 2, |
| layout_provider->GetDistanceMetric( |
| DISTANCE_BUTTON_HORIZONTAL_PADDING)))); |
| |
| item->SetEnabled(model_field->is_enabled()); |
| item->SetProperty(kElementIdentifierKey, model_field->id()); |
| |
| DialogModelHostField info{model_field, item.get(), nullptr}; |
| AddDialogModelHostField(std::move(item), info); |
| } |
| |
| void AddOrUpdatePasswordField(ui::DialogModelPasswordField* model_field) { |
| // TODO(pbos): Support updates to the existing model. |
| |
| auto view = std::make_unique<BoxLayoutView>(); |
| view->SetOrientation(BoxLayout::Orientation::kVertical); |
| |
| std::unique_ptr<Label> error_label; |
| if (!model_field->incorrect_password_text().empty()) { |
| // TODO(droger): Implement the supporting text directly in Textfield. |
| error_label = std::make_unique<Label>( |
| model_field->incorrect_password_text(), |
| style::CONTEXT_TEXTFIELD_SUPPORTING_TEXT, style::STYLE_INVALID); |
| error_label->SetMultiLine(true); |
| error_label->SetHorizontalAlignment(gfx::ALIGN_LEFT); |
| error_label->SetVisible(false); |
| } |
| |
| // Use a combobox with empty model, rather than a Textfield, so that it |
| // supports the "reveal" functionality (eye icon). |
| // TODO(droger): add better support for passwords in the regular Textfield. |
| auto password_combobox = std::make_unique<views::EditablePasswordCombobox>( |
| std::make_unique<ui::SimpleComboboxModel>( |
| std::vector<ui::SimpleComboboxModel::Item>()), |
| views::style::CONTEXT_TEXTFIELD, style::STYLE_PRIMARY_MONOSPACED, |
| false); |
| password_combobox->SetPasswordIconTooltips( |
| l10n_util::GetStringUTF16(IDS_SETTINGS_PASSWORD_SHOW), |
| l10n_util::GetStringUTF16(IDS_SETTINGS_PASSWORD_HIDE)); |
| password_combobox->GetViewAccessibility().SetName( |
| model_field->accessible_name().empty() |
| ? model_field->label() |
| : model_field->accessible_name()); |
| |
| password_combobox->SetCallback(base::BindRepeating( |
| [](ui::DialogModelPasswordField* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, |
| EditablePasswordCombobox* combobox, Label* error_label) { |
| model_field->OnTextChanged(pass_key, combobox->GetText()); |
| combobox->SetInvalid(false); |
| if (error_label) { |
| error_label->SetVisible(false); |
| } |
| }, |
| model_field, GetPassKey(), password_combobox.get(), error_label.get())); |
| |
| property_changed_subscriptions_.push_back( |
| model_field->AddOnInvalidateCallback( |
| GetPassKey(), |
| base::BindRepeating( |
| [](EditablePasswordCombobox* combobox, Label* error_label) { |
| combobox->SetText(std::u16string()); |
| combobox->SetInvalid(true); |
| if (error_label) { |
| error_label->SetVisible(true); |
| error_label->GetViewAccessibility().AnnounceAlert( |
| error_label->GetText()); |
| } |
| }, |
| password_combobox.get(), error_label.get()))); |
| |
| view->AddChildView(std::move(password_combobox)); |
| if (error_label) { |
| view->AddChildView(std::move(error_label)); |
| } |
| |
| AddViewForLabelAndField(model_field, model_field->label(), std::move(view)); |
| } |
| |
| void AddOrUpdateTextfield(ui::DialogModelTextfield* model_field) { |
| // TODO(pbos): Support updates to the existing model. |
| |
| auto textfield = std::make_unique<Textfield>(); |
| textfield->GetViewAccessibility().SetName( |
| model_field->accessible_name().empty() |
| ? model_field->label() |
| : model_field->accessible_name()); |
| textfield->SetText(model_field->text()); |
| |
| // If this textfield is initially focused the text should be initially |
| // selected as well. |
| // TODO(pbos): Fix this for non-unique IDs. This should not select all text |
| // for all textfields with that ID. |
| if (initially_focused_field_id_ && |
| model_field->id() == initially_focused_field_id_) { |
| textfield->SelectAll(true); |
| } |
| |
| property_changed_subscriptions_.push_back( |
| textfield->AddTextChangedCallback(base::BindRepeating( |
| [](ui::DialogModelTextfield* model_field, |
| base::PassKey<DialogModelFieldHost> pass_key, |
| Textfield* textfield) { |
| model_field->OnTextChanged(pass_key, |
| std::u16string(textfield->GetText())); |
| }, |
| model_field, GetPassKey(), textfield.get()))); |
| |
| AddViewForLabelAndField(model_field, model_field->label(), |
| std::move(textfield)); |
| } |
| |
| void AddOrUpdateCustomField(ui::DialogModelCustomField* model_field) { |
| auto* custom_view = |
| static_cast<BubbleDialogModelHost::CustomView*>(model_field->field()); |
| std::unique_ptr<View> view = custom_view->TransferView(); |
| View* focusable_view = custom_view->TransferFocusableView(); |
| if (!focusable_view) { |
| CHECK(view); |
| view->SetProperty(kElementIdentifierKey, model_field->id()); |
| } |
| DialogModelHostField info{model_field, view.get(), focusable_view}; |
| AddDialogModelHostField(std::move(view), info); |
| } |
| |
| void AddOrUpdateSeparator(ui::DialogModelField* model_field) { |
| DCHECK_EQ(ui::DialogModelField::Type::kSeparator, model_field->type()); |
| // TODO(pbos): Support updates to the existing model. |
| |
| auto separator = std::make_unique<Separator>(); |
| DialogModelHostField info{model_field, separator.get(), nullptr}; |
| AddDialogModelHostField(std::move(separator), info); |
| } |
| |
| void AddViewForLabelAndField(ui::DialogModelField* model_field, |
| const std::u16string& label_text, |
| std::unique_ptr<View> field) { |
| auto box_layout = std::make_unique<BoxLayoutView>(); |
| |
| box_layout->SetBetweenChildSpacing(LayoutProvider::Get()->GetDistanceMetric( |
| DISTANCE_RELATED_CONTROL_HORIZONTAL)); |
| |
| DialogModelHostField info{model_field, box_layout.get(), field.get()}; |
| |
| auto label = std::make_unique<Label>(label_text, style::CONTEXT_LABEL, |
| style::STYLE_PRIMARY); |
| label->SetHorizontalAlignment(gfx::ALIGN_LEFT); |
| |
| box_layout->AddChildView(std::make_unique<LayoutConsensusView>( |
| &textfield_first_column_group_, std::move(label))); |
| box_layout->SetFlexForView( |
| box_layout->AddChildView(std::make_unique<LayoutConsensusView>( |
| &textfield_second_column_group_, std::move(field))), |
| 1); |
| |
| AddDialogModelHostField(std::move(box_layout), info); |
| } |
| |
| static bool DialogModelLabelRequiresStyledLabel( |
| const ui::DialogModelLabel& dialog_label) { |
| return !dialog_label.replacements().empty(); |
| } |
| |
| static std::unique_ptr<View> CreateViewForLabel( |
| const ui::DialogModelLabel& dialog_label) { |
| if (DialogModelLabelRequiresStyledLabel(dialog_label)) { |
| return CreateStyledLabelForDialogModelLabel(dialog_label); |
| } |
| return CreateLabelForDialogModelLabel(dialog_label); |
| } |
| |
| static std::unique_ptr<StyledLabel> CreateStyledLabelForDialogModelLabel( |
| const ui::DialogModelLabel& dialog_label) { |
| DCHECK(DialogModelLabelRequiresStyledLabel(dialog_label)); |
| const std::vector<ui::DialogModelLabel::TextReplacement>& replacements = |
| dialog_label.replacements(); |
| |
| // Retrieve the replacements strings to create the text. |
| std::vector<std::u16string> string_replacements; |
| for (auto replacement : replacements) { |
| string_replacements.push_back(replacement.text()); |
| } |
| std::vector<size_t> offsets; |
| const std::u16string text = l10n_util::GetStringFUTF16( |
| dialog_label.message_id(), string_replacements, &offsets); |
| |
| auto styled_label = std::make_unique<StyledLabel>(); |
| styled_label->SetText(text); |
| styled_label->SetDefaultTextStyle(dialog_label.is_secondary() |
| ? style::STYLE_SECONDARY |
| : style::STYLE_PRIMARY); |
| |
| // Style the replacements as needed. |
| DCHECK_EQ(string_replacements.size(), offsets.size()); |
| for (size_t i = 0; i < replacements.size(); ++i) { |
| auto replacement = replacements[i]; |
| // No styling needed if replacement is neither a link nor emphasized text. |
| if (!replacement.callback().has_value() && !replacement.is_emphasized()) { |
| continue; |
| } |
| |
| StyledLabel::RangeStyleInfo style_info; |
| if (replacement.callback().has_value()) { |
| style_info = StyledLabel::RangeStyleInfo::CreateForLink( |
| replacement.callback().value()); |
| style_info.accessible_name = replacement.accessible_name().value(); |
| } else if (replacement.is_emphasized()) { |
| style_info.text_style = views::style::STYLE_EMPHASIZED; |
| } |
| |
| auto offset = offsets[i]; |
| styled_label->AddStyleRange( |
| gfx::Range(offset, offset + replacement.text().length()), style_info); |
| } |
| |
| return styled_label; |
| } |
| |
| static std::unique_ptr<Label> CreateLabelForDialogModelLabel( |
| const ui::DialogModelLabel& dialog_label) { |
| DCHECK(!DialogModelLabelRequiresStyledLabel(dialog_label)); |
| |
| auto text_label = std::make_unique<Label>( |
| dialog_label.GetString(), style::CONTEXT_DIALOG_BODY_TEXT, |
| dialog_label.is_secondary() ? style::STYLE_SECONDARY |
| : style::STYLE_PRIMARY); |
| text_label->SetMultiLine(true); |
| text_label->SetHorizontalAlignment(gfx::ALIGN_LEFT); |
| return text_label; |
| } |
| |
| std::unique_ptr<View> CreateViewForParagraphWithHeader( |
| const ui::DialogModelLabel& dialog_label, |
| const std::u16string& header) { |
| auto view = std::make_unique<BoxLayoutView>(); |
| view->SetOrientation(BoxLayout::Orientation::kVertical); |
| |
| auto* header_label = view->AddChildView(std::make_unique<Label>( |
| header, style::CONTEXT_DIALOG_BODY_TEXT, style::STYLE_PRIMARY)); |
| header_label->SetHorizontalAlignment(gfx::ALIGN_LEFT); |
| |
| view->AddChildView(CreateViewForLabel(dialog_label)); |
| return view; |
| } |
| |
| void AddDialogModelHostField(std::unique_ptr<View> view, |
| const DialogModelHostField& field_view_info) { |
| DCHECK_EQ(view.get(), field_view_info.field_view); |
| |
| AddChildView(std::move(view)); |
| |
| DCHECK(field_view_info.dialog_model_field); |
| DCHECK(field_view_info.field_view); |
| #if DCHECK_IS_ON() |
| // Make sure none of the info is already in use. |
| for (const auto& info : fields_) { |
| DCHECK_NE(info.field_view, field_view_info.field_view); |
| DCHECK_NE(info.dialog_model_field, field_view_info.dialog_model_field); |
| if (info.focusable_view) { |
| DCHECK_NE(info.focusable_view, field_view_info.focusable_view); |
| } |
| } |
| #endif // DCHECK_IS_ON() |
| fields_.push_back(field_view_info); |
| View* const target = GetTargetView(field_view_info); |
| target->SetProperty(kElementIdentifierKey, |
| field_view_info.dialog_model_field->id()); |
| for (const auto& accelerator : |
| field_view_info.dialog_model_field->accelerators()) { |
| target->AddAccelerator(accelerator); |
| } |
| } |
| |
| DialogModelHostField FindDialogModelHostField(ui::DialogModelField* field) { |
| for (const auto& info : fields_) { |
| if (info.dialog_model_field == field) { |
| return info; |
| } |
| } |
| // TODO(pbos): `field` could correspond to a button. |
| return {}; |
| } |
| |
| DialogModelHostField FindDialogModelHostField(View* view) { |
| for (const auto& info : fields_) { |
| if (info.field_view == view) { |
| return info; |
| } |
| } |
| NOTREACHED(); |
| } |
| |
| private: |
| // TODO(pbos): These should be const as we should never outlive our parent or |
| // DialogModelSection. Currently this isn't true because WidgetDelegate gets |
| // destroyed by Widget in OnNativeWidgetDestroyed before the content gets |
| // destroyed inside DestroyRootView in ~Widget. |
| raw_ptr<ui::DialogModelSection> contents_; |
| |
| const ui::ElementIdentifier initially_focused_field_id_; |
| |
| const base::CallbackListSubscription on_field_added_subscription_; |
| const base::CallbackListSubscription on_field_changed_subscription_; |
| |
| std::vector<DialogModelHostField> fields_; |
| // TODO(pbos): Try to work away this list if the parent can observe enough |
| // things as a ViewObserver of us. |
| base::RepeatingClosureList on_contents_changed_; |
| |
| std::vector<base::CallbackListSubscription> property_changed_subscriptions_; |
| |
| LayoutConsensusGroup textfield_first_column_group_; |
| LayoutConsensusGroup textfield_second_column_group_; |
| }; |
| |
| BEGIN_METADATA(BubbleDialogModelHostContentsView) |
| END_METADATA |
| |
| std::unique_ptr<DialogModelSectionHost> DialogModelSectionHost::Create( |
| ui::DialogModelSection* section, |
| ui::ElementIdentifier initially_focused_field_id) { |
| return std::make_unique<BubbleDialogModelHostContentsView>( |
| section, initially_focused_field_id); |
| } |
| |
| BEGIN_METADATA(DialogModelSectionHost) |
| END_METADATA |
| |
| BubbleDialogModelHost::ThemeChangedObserver::ThemeChangedObserver( |
| BubbleDialogModelHost* parent, |
| BubbleDialogModelHostContentsView* contents_view) |
| : parent_(parent) { |
| observation_.Observe(contents_view); |
| } |
| BubbleDialogModelHost::ThemeChangedObserver::~ThemeChangedObserver() = default; |
| |
| void BubbleDialogModelHost::ThemeChangedObserver::OnViewThemeChanged( |
| View* view) { |
| parent_->UpdateWindowIcon(view->GetColorProvider()); |
| } |
| |
| BubbleDialogModelHost::BubbleDialogModelHost( |
| std::unique_ptr<ui::DialogModel> model, |
| View* anchor_view, |
| BubbleBorder::Arrow arrow, |
| bool autosize) |
| : BubbleDialogModelHost(base::PassKey<BubbleDialogModelHost>(), |
| std::move(model), |
| anchor_view, |
| arrow, |
| ui::mojom::ModalType::kNone, |
| autosize) {} |
| |
| BubbleDialogModelHost::BubbleDialogModelHost( |
| base::PassKey<BubbleDialogModelHost>, |
| std::unique_ptr<ui::DialogModel> model, |
| View* anchor_view, |
| BubbleBorder::Arrow arrow, |
| ui::mojom::ModalType modal_type, |
| bool autosize) |
| : BubbleDialogDelegate(anchor_view, |
| arrow, |
| views::BubbleBorder::DIALOG_SHADOW, |
| autosize), |
| model_(std::move(model)), |
| // Make sure the modal type is set before calling InitContentsView which |
| // uses IsModalDialog(). |
| contents_view_( |
| (SetModalType(modal_type), InitContentsView(model_->contents()))), |
| on_contents_changed_subscription_( |
| contents_view_->AddOnContentsChangedCallback( |
| base::BindRepeating(&BubbleDialogModelHost::OnContentsViewChanged, |
| base::Unretained(this)))), |
| theme_observer_(this, contents_view_) { |
| SetOwnedByWidget(OwnedByWidgetPassKey()); |
| model_->set_host(DialogModelHost::GetPassKey(), this); |
| |
| // Dialog callbacks can safely refer to |model_|, they can't be called after |
| // Widget::Close() calls WidgetWillClose() synchronously so there shouldn't |
| // be any dangling references after model removal. |
| SetAcceptCallbackWithClose(base::BindRepeating( |
| &ui::DialogModel::OnDialogAcceptAction, base::Unretained(model_.get()), |
| DialogModelHost::GetPassKey())); |
| SetCancelCallbackWithClose(base::BindRepeating( |
| &ui::DialogModel::OnDialogCancelAction, base::Unretained(model_.get()), |
| DialogModelHost::GetPassKey())); |
| SetCloseCallback(base::BindOnce(&ui::DialogModel::OnDialogCloseAction, |
| base::Unretained(model_.get()), |
| DialogModelHost::GetPassKey())); |
| |
| // WindowClosingCallback happens on native widget destruction which is after |
| // |model_| reset. Hence routing this callback through |this| so that we |
| // only forward the call to DialogModel::OnWindowClosing if we haven't |
| // already been closed. |
| RegisterWindowClosingCallback(base::BindOnce( |
| &BubbleDialogModelHost::OnWindowClosing, base::Unretained(this))); |
| |
| int button_mask = static_cast<int>(ui::mojom::DialogButton::kNone); |
| auto* ok_button = model_->ok_button(DialogModelHost::GetPassKey()); |
| if (ok_button) { |
| button_mask |= static_cast<int>(ui::mojom::DialogButton::kOk); |
| ConfigureBubbleButtonForParams(*this, /*button_view=*/nullptr, |
| ui::mojom::DialogButton::kOk, *ok_button); |
| } |
| |
| auto* cancel_button = model_->cancel_button(DialogModelHost::GetPassKey()); |
| if (cancel_button) { |
| button_mask |= static_cast<int>(ui::mojom::DialogButton::kCancel); |
| ConfigureBubbleButtonForParams(*this, /*button_view=*/nullptr, |
| ui::mojom::DialogButton::kCancel, |
| *cancel_button); |
| } |
| |
| // TODO(pbos): Consider refactoring ::SetExtraView() so it can be called |
| // after the Widget is created and still be picked up. Moving this to |
| // OnWidgetInitialized() will not work until then. |
| if (ui::DialogModel::Button* extra_button = |
| model_->extra_button(DialogModelHost::GetPassKey())) { |
| DCHECK(!model_->extra_link(DialogModelHost::GetPassKey())); |
| auto builder = |
| views::Builder<MdTextButton>() |
| .SetCallback(base::BindRepeating( |
| &ui::DialogModel::Button::OnPressed, |
| base::Unretained(extra_button), DialogModelHost::GetPassKey())) |
| .SetText(extra_button->label()); |
| if (extra_button->style()) { |
| builder.SetStyle(extra_button->style().value()); |
| } |
| builder.SetEnabled(extra_button->is_enabled()); |
| SetExtraView(std::move(builder).Build()); |
| } else if (ui::DialogModelLabel::TextReplacement* extra_link = |
| model_->extra_link(DialogModelHost::GetPassKey())) { |
| DCHECK(extra_link->callback().has_value()); |
| auto link = std::make_unique<views::Link>(extra_link->text()); |
| link->SetCallback(extra_link->callback().value()); |
| SetExtraView(std::move(link)); |
| } |
| |
| SetButtons(button_mask); |
| |
| if (model_->override_default_button(DialogModelHost::GetPassKey())) { |
| SetDefaultButton(static_cast<int>( |
| model_->override_default_button(DialogModelHost::GetPassKey()) |
| .value())); |
| } |
| |
| SetTitle(model_->title(DialogModelHost::GetPassKey())); |
| |
| if (!model_->accessible_title(DialogModelHost::GetPassKey()).empty()) { |
| SetAccessibleTitle(model_->accessible_title(DialogModelHost::GetPassKey())); |
| } |
| |
| SetSubtitle(model_->subtitle(DialogModelHost::GetPassKey())); |
| // This is added due to crbug.com/1518993 which adds a subtitle that needs |
| // line wrapping. If any future dialogs need the subtitle to not line wrap, |
| // this behavior will need to be configurable via the builder. |
| SetSubtitleAllowCharacterBreak(true); |
| |
| if (!model_->main_image(DialogModelHost::GetPassKey()).IsEmpty()) { |
| SetMainImage(model_->main_image(DialogModelHost::GetPassKey())); |
| } |
| |
| if (model_->override_show_close_button(DialogModelHost::GetPassKey())) { |
| SetShowCloseButton( |
| *model_->override_show_close_button(DialogModelHost::GetPassKey())); |
| } else { |
| SetShowCloseButton(!IsModalDialog()); |
| } |
| |
| if (!model_->icon(DialogModelHost::GetPassKey()).IsEmpty()) { |
| SetIcon(model_->icon(DialogModelHost::GetPassKey())); |
| SetShowIcon(true); |
| } |
| |
| if (model_->is_alert_dialog(DialogModelHost::GetPassKey())) { |
| #if BUILDFLAG(IS_WIN) |
| // This is taken from LocationBarBubbleDelegateView. See |
| // GetAccessibleRoleForReason(). crbug.com/1125118: Windows ATs only |
| // announce these bubbles if the alert role is used, despite it not being |
| // the most appropriate choice. |
| // TODO(accessibility): review the role mappings for alerts and dialogs, |
| // making sure they are translated to the best candidate in each flatform |
| // without resorting to hacks like this. |
| SetAccessibleWindowRole(ax::mojom::Role::kAlert); |
| #else |
| SetAccessibleWindowRole(ax::mojom::Role::kAlertDialog); |
| #endif |
| } |
| |
| set_internal_name(model_->internal_name(DialogModelHost::GetPassKey())); |
| |
| set_close_on_deactivate( |
| model_->close_on_deactivate(DialogModelHost::GetPassKey())); |
| |
| // TODO(pbos): Reconsider this for dialogs which have no actions (look like |
| // menus). This is probably too wide for the TabGroupEditorBubbleView which is |
| // currently being converted. |
| set_fixed_width(LayoutProvider::Get()->GetDistanceMetric( |
| anchor_view ? DISTANCE_BUBBLE_PREFERRED_WIDTH |
| : DISTANCE_MODAL_DIALOG_PREFERRED_WIDTH)); |
| |
| if (model_->footnote_label()) { |
| SetFootnoteView(BubbleDialogModelHostContentsView::CreateViewForLabel( |
| *model_->footnote_label())); |
| } |
| |
| // Make sure we're up to date with initial contents state. |
| UpdateSpacingAndMargins(); |
| } |
| |
| BubbleDialogModelHost::~BubbleDialogModelHost() { |
| // Detach ContentsView as it's referring to state that's about to be |
| // destroyed. |
| contents_view_->Detach(); |
| } |
| |
| std::unique_ptr<BubbleDialogModelHost> BubbleDialogModelHost::CreateModal( |
| std::unique_ptr<ui::DialogModel> model, |
| ui::mojom::ModalType modal_type, |
| bool autosize) { |
| DCHECK_NE(modal_type, ui::mojom::ModalType::kNone); |
| return std::make_unique<BubbleDialogModelHost>( |
| base::PassKey<BubbleDialogModelHost>(), std::move(model), nullptr, |
| BubbleBorder::Arrow::NONE, modal_type, autosize); |
| } |
| |
| View* BubbleDialogModelHost::GetInitiallyFocusedView() { |
| // TODO(pbos): Migrate this override to use |
| // WidgetDelegate::SetInitiallyFocusedView() in constructor once it exists. |
| // TODO(pbos): Try to prevent uses of GetInitiallyFocusedView() after Close() |
| // and turn this in to a DCHECK for |model_| existence. This should fix |
| // https://crbug.com/1130181 for now. |
| if (!model_) { |
| return BubbleDialogDelegate::GetInitiallyFocusedView(); |
| } |
| |
| // TODO(pbos): Reconsider the uniqueness requirement, maybe this should select |
| // the first one? If so add corresponding GetFirst query to DialogModel. |
| ui::ElementIdentifier unique_id = |
| model_->initially_focused_field(DialogModelHost::GetPassKey()); |
| |
| if (!unique_id) { |
| return BubbleDialogDelegate::GetInitiallyFocusedView(); |
| } |
| |
| if (ui::DialogModel::Button* const ok_button = |
| model_->ok_button(DialogModelHost::GetPassKey()); |
| ok_button && unique_id == ok_button->id()) { |
| return GetOkButton(); |
| } |
| |
| if (ui::DialogModel::Button* const cancel_button = |
| model_->cancel_button(DialogModelHost::GetPassKey()); |
| cancel_button && unique_id == cancel_button->id()) { |
| return GetCancelButton(); |
| } |
| |
| if (ui::DialogModel::Button* const extra_button = |
| model_->extra_button(DialogModelHost::GetPassKey()); |
| extra_button && unique_id == extra_button->id()) { |
| return GetExtraView(); |
| } |
| |
| return GetTargetView(contents_view_->FindDialogModelHostField( |
| model_->GetFieldByUniqueId(unique_id))); |
| } |
| |
| void BubbleDialogModelHost::OnWidgetInitialized() { |
| // Dialog buttons are added on dialog initialization. |
| UpdateDialogButtons(); |
| |
| if (const ui::ImageModel& banner = |
| model_->banner(DialogModelHost::GetPassKey()); |
| !banner.IsEmpty()) { |
| const ui::ImageModel& dark_mode_banner = |
| model_->dark_mode_banner(DialogModelHost::GetPassKey()); |
| auto banner_view = std::make_unique<ThemeTrackingImageView>( |
| banner.Rasterize(contents_view_->GetColorProvider()), |
| (dark_mode_banner.IsEmpty() ? banner : dark_mode_banner) |
| .Rasterize(contents_view_->GetColorProvider()), |
| base::BindRepeating(&views::BubbleDialogDelegate::background_color, |
| base::Unretained(this))); |
| // The banner is supposed to be purely decorative. |
| banner_view->GetViewAccessibility().SetIsIgnored(true); |
| GetBubbleFrameView()->SetHeaderView(std::move(banner_view)); |
| } |
| } |
| |
| void BubbleDialogModelHost::Close() { |
| DCHECK(model_); |
| DCHECK(GetWidget()); |
| GetWidget()->Close(); |
| |
| // Synchronously destroy |model_|. Widget::Close() being asynchronous should |
| // not be observable by the model or client code. |
| |
| // Notify the model of window closing before destroying it (as if |
| // Widget::Close) |
| model_->OnDialogDestroying(DialogModelHost::GetPassKey()); |
| |
| // Detach ContentsView as it's referring to state that's about to be |
| // destroyed. |
| contents_view_->Detach(); |
| model_.reset(); |
| } |
| |
| BubbleDialogModelHostContentsView* BubbleDialogModelHost::InitContentsView( |
| ui::DialogModelSection* contents) { |
| auto contents_view_unique = |
| std::make_unique<BubbleDialogModelHostContentsView>( |
| contents, |
| model_->initially_focused_field(DialogModelHost::GetPassKey())); |
| |
| BubbleDialogModelHostContentsView* const contents_view = |
| contents_view_unique.get(); |
| |
| if (IsModalDialog()) { |
| // Margins are added directly in the dialog. When the dialog is modal, these |
| // contents are wrapped by a scroll view and margins are added outside of it |
| // (instead of outside this contents). This causes some items (e.g |
| // emphasized buttons) to be cut by the scroll view margins (see |
| // crbug.com/1360772). Since we do want the margins outside the scroll view |
| // (so they are always present when scrolling), we add |
| // `kScrollViewVerticalMargin` inside the contents view and later remove it |
| // from the dialog margins. |
| // TODO(crbug.com/40855129): Remove this workaround when contents view |
| // directly supports a scroll view. |
| contents_view_unique->SetInsideBorderInsets( |
| gfx::Insets::VH(kScrollViewVerticalMargin, 0)); |
| |
| // TODO(crbug.com/40855129): Non modal dialogs size is not dependent on its |
| // content. Thus, the content has to be manually set by the view inside a |
| // scroll view. Modal dialogs handle their own size via constrained windows, |
| // so we can add a scroll view to the DialogModel directly. |
| const int kMaxDialogHeight = LayoutProvider::Get()->GetDistanceMetric( |
| DISTANCE_MODAL_DIALOG_SCROLLABLE_AREA_MAX_HEIGHT); |
| auto scroll_view = std::make_unique<views::ScrollView>(); |
| scroll_view->ClipHeightTo(0, kMaxDialogHeight); |
| scroll_view->SetHorizontalScrollBarMode( |
| views::ScrollView::ScrollBarMode::kDisabled); |
| scroll_view->SetContents(std::move(contents_view_unique)); |
| SetContentsView(std::move(scroll_view)); |
| } else { |
| SetContentsView(std::move(contents_view_unique)); |
| } |
| return contents_view; |
| } |
| |
| void BubbleDialogModelHost::OnContentsViewChanged() { |
| UpdateSpacingAndMargins(); |
| } |
| |
| void BubbleDialogModelHost::OnDialogButtonChanged() { |
| UpdateDialogButtons(); |
| } |
| |
| void BubbleDialogModelHost::UpdateWindowIcon( |
| const ui::ColorProvider* color_provider) { |
| if (!ShouldShowWindowIcon()) { |
| return; |
| } |
| const ui::ImageModel dark_mode_icon = |
| model_->dark_mode_icon(DialogModelHost::GetPassKey()); |
| if (!dark_mode_icon.IsEmpty() && |
| color_utils::IsDark( |
| background_color().ResolveToSkColor(color_provider))) { |
| SetIcon(dark_mode_icon); |
| return; |
| } |
| SetIcon(model_->icon(DialogModelHost::GetPassKey())); |
| } |
| |
| void BubbleDialogModelHost::UpdateSpacingAndMargins() { |
| LayoutProvider* const layout_provider = LayoutProvider::Get(); |
| gfx::Insets dialog_side_insets = |
| layout_provider->GetInsetsMetric(InsetsMetric::INSETS_DIALOG); |
| if (GetWindowTitle().empty()) { |
| // If there is no title, increase the margin at the top to match the title |
| // margin, so that the text is not too close to the top edge. |
| dialog_side_insets.set_top( |
| layout_provider->GetInsetsMetric(InsetsMetric::INSETS_DIALOG_TITLE) |
| .top()); |
| } else { |
| dialog_side_insets.set_top(0); |
| } |
| dialog_side_insets.set_bottom(0); |
| |
| ui::DialogModelField* first_field = nullptr; |
| ui::DialogModelField* last_field = nullptr; |
| |
| auto* scroll_view = |
| views::ScrollView::GetScrollViewForContents(contents_view_); |
| const views::View::Views& children = scroll_view |
| ? scroll_view->contents()->children() |
| : contents_view_->children(); |
| |
| if (children.empty()) { |
| // TODO(pbos): Copied from the BubbleDialogDelegate constructor. Maybe there |
| // should be a way to reset them if we become empty? |
| set_margins(layout_provider->GetDialogInsetsForContentType( |
| DialogContentType::kText, DialogContentType::kText)); |
| return; |
| } |
| |
| for (View* const view : children) { |
| ui::DialogModelField* const field = |
| contents_view_->FindDialogModelHostField(view).dialog_model_field; |
| |
| const FieldType field_type = GetFieldTypeForField(field); |
| |
| gfx::Insets side_insets = |
| field_type == FieldType::kMenuItem ? gfx::Insets() : dialog_side_insets; |
| |
| if (!first_field) { |
| first_field = field; |
| view->SetProperty(kMarginsKey, side_insets); |
| } else { |
| DCHECK(last_field); |
| |
| const FieldType last_field_type = GetFieldTypeForField(last_field); |
| side_insets.set_top( |
| GetFieldTopMargin(layout_provider, field_type, last_field_type)); |
| view->SetProperty(kMarginsKey, side_insets); |
| } |
| last_field = field; |
| } |
| |
| contents_view_->InvalidateLayout(); |
| // Set margins based on the first and last item. Note that we remove margins |
| // that were already added to contents view at construction. |
| // TODO(crbug.com/40855129): Remove the extra margin workaround when contents |
| // view directly supports a scroll view. |
| const int extra_margin = scroll_view ? kScrollViewVerticalMargin : 0; |
| const int top_margin = |
| GetDialogTopMargins(layout_provider, first_field) - extra_margin; |
| const int bottom_margin = |
| GetDialogBottomMargins( |
| layout_provider, last_field, |
| buttons() != static_cast<int>(ui::mojom::DialogButton::kNone)) - |
| extra_margin; |
| set_margins(gfx::Insets::TLBR(top_margin >= 0 ? top_margin : 0, 0, |
| bottom_margin >= 0 ? bottom_margin : 0, 0)); |
| } |
| |
| void BubbleDialogModelHost::OnWindowClosing() { |
| // If the model has been removed we have already notified it of closing on the |
| // ::Close() stack. |
| if (!model_) { |
| return; |
| } |
| model_->OnDialogDestroying(DialogModelHost::GetPassKey()); |
| // TODO(pbos): Do we need to reset `model_` and destroy contents? See Close(). |
| } |
| |
| void BubbleDialogModelHost::UpdateDialogButtons() { |
| if (ui::DialogModel::Button* const ok_button = |
| model_->ok_button(DialogModelHost::GetPassKey())) { |
| ConfigureBubbleButtonForParams(*this, GetOkButton(), |
| ui::mojom::DialogButton::kOk, *ok_button); |
| } |
| if (ui::DialogModel::Button* const cancel_button = |
| model_->cancel_button(DialogModelHost::GetPassKey())) { |
| ConfigureBubbleButtonForParams(*this, GetCancelButton(), |
| ui::mojom::DialogButton::kCancel, |
| *cancel_button); |
| } |
| if (ui::DialogModel::Button* const extra_button = |
| model_->extra_button(DialogModelHost::GetPassKey())) { |
| auto* const extra_button_view = static_cast<MdTextButton*>(GetExtraView()); |
| extra_button_view->SetText(extra_button->label()); |
| extra_button_view->SetVisible(extra_button->is_visible()); |
| extra_button_view->SetEnabled(extra_button->is_enabled()); |
| extra_button_view->SetProperty(kElementIdentifierKey, extra_button->id()); |
| } |
| } |
| |
| bool BubbleDialogModelHost::IsModalDialog() const { |
| return GetModalType() != ui::mojom::ModalType::kNone; |
| } |
| |
| } // namespace views |
