// 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 "chrome/browser/ui/ash/input_method/suggestion_window_view.h"
#include <string>
#include <utility>
#include "base/functional/bind.h"
#include "base/i18n/number_formatting.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/browser/ash/input_method/assistive_window_properties.h"
#include "chrome/browser/ui/ash/input_method/assistive_delegate.h"
#include "chrome/browser/ui/ash/input_method/border_factory.h"
#include "chrome/browser/ui/ash/input_method/colors.h"
#include "chrome/browser/ui/ash/input_method/completion_suggestion_view.h"
#include "chrome/browser/ui/ash/input_method/suggestion_details.h"
#include "chrome/grit/generated_resources.h"
#include "components/strings/grit/components_strings.h"
#include "components/vector_icons/vector_icons.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/mojom/dialog_button.mojom.h"
#include "ui/base/ui_base_types.h"
#include "ui/color/color_id.h"
#include "ui/color/color_provider.h"
#include "ui/gfx/color_palette.h"
#include "ui/gfx/font.h"
#include "ui/gfx/font_list.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/gfx/text_constants.h"
#include "ui/views/background.h"
#include "ui/views/border.h"
#include "ui/views/bubble/bubble_border.h"
#include "ui/views/bubble/bubble_frame_view.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/link.h"
#include "ui/views/layout/box_layout.h"
#include "ui/views/layout/layout_provider.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/core/window_animations.h"
#include "ui/wm/core/window_properties.h"
namespace ui {
namespace ime {
namespace {
bool ShouldHighlight(const views::Button& button) {
return button.GetState() == views::Button::STATE_HOVERED ||
button.GetState() == views::Button::STATE_PRESSED;
}
// TODO(b/1101669): Create abstract HighlightableButton for learn_more button,
// setting_link_, suggestion_view and undo_view.
void SetHighlighted(views::View& view, bool highlighted) {
if (!!view.background() != highlighted) {
view.SetBackground(highlighted
? views::CreateRoundedRectBackground(
ResolveSemanticColor(kButtonHighlightColor), 2)
: nullptr);
}
}
} // namespace
// static
SuggestionWindowView* SuggestionWindowView::Create(gfx::NativeView parent,
AssistiveDelegate* delegate,
Orientation orientation) {
auto* const view = new SuggestionWindowView(parent, delegate, orientation);
views::Widget* const widget =
views::BubbleDialogDelegateView::CreateBubble(view);
wm::SetWindowVisibilityAnimationTransition(widget->GetNativeView(),
wm::ANIMATE_NONE);
return view;
}
std::unique_ptr<views::NonClientFrameView>
SuggestionWindowView::CreateNonClientFrameView(views::Widget* widget) {
std::unique_ptr<views::NonClientFrameView> frame =
views::BubbleDialogDelegateView::CreateNonClientFrameView(widget);
static_cast<views::BubbleFrameView*>(frame.get())
->SetBubbleBorder(GetBorderForWindow(WindowBorderType::Suggestion));
return frame;
}
void SuggestionWindowView::Show(const SuggestionDetails& details) {
ResizeCandidateArea({});
Reorient(Orientation::kVertical);
completion_view_->SetVisible(true);
completion_view_->SetView(details);
if (details.show_setting_link) {
completion_view_->SetMinWidth(
setting_link_
->GetPreferredSize(views::SizeBounds(setting_link_->width(), {}))
.width());
}
setting_link_->SetVisible(details.show_setting_link);
MakeVisible();
}
void SuggestionWindowView::ShowMultipleCandidates(
const ash::input_method::AssistiveWindowProperties& properties,
Orientation orientation) {
const std::vector<std::u16string>& candidates = properties.candidates;
completion_view_->SetVisible(false);
Reorient(orientation, /*extra_padding_on_right=*/
properties.type !=
ash::ime::AssistiveWindowType::kLongpressDiacriticsSuggestion);
ResizeCandidateArea(
candidates,
properties.type == ash::ime::AssistiveWindowType::kEmojiSuggestion);
learn_more_button_->SetVisible(properties.show_setting_link);
type_ = properties.type;
// Ensure colours are correct.
OnThemeChanged();
MakeVisible();
}
void SuggestionWindowView::SetButtonHighlighted(
const AssistiveWindowButton& button,
bool highlighted) {
if (button.id == ButtonId::kSuggestion) {
if (completion_view_->GetVisible()) {
completion_view_->SetHighlighted(highlighted);
} else {
const views::View::Views& candidate_buttons =
multiple_candidate_area_->children();
if (button.suggestion_index < candidate_buttons.size()) {
SetCandidateHighlighted(static_cast<IndexedSuggestionCandidateButton*>(
candidate_buttons[button.suggestion_index]),
highlighted);
}
}
} else if (button.id == ButtonId::kSmartInputsSettingLink) {
SetHighlighted(*setting_link_, highlighted);
} else if (button.id == ButtonId::kLearnMore) {
SetHighlighted(*learn_more_button_, highlighted);
}
}
gfx::Rect SuggestionWindowView::GetBubbleBounds() {
// The bubble bounds must be shifted to align with the anchor if there is a
// completion view.
const gfx::Point anchor_origin = completion_view_->GetVisible()
? completion_view_->GetAnchorOrigin()
: gfx::Point(0, 0);
return BubbleDialogDelegateView::GetBubbleBounds() -
anchor_origin.OffsetFromOrigin();
}
void SuggestionWindowView::OnThemeChanged() {
BubbleDialogDelegateView::OnThemeChanged();
const auto* const color_provider = GetColorProvider();
if (type_ == ash::ime::AssistiveWindowType::kLongpressDiacriticsSuggestion) {
const int inset = views::LayoutProvider::Get()->GetDistanceMetric(
views::DistanceMetric::DISTANCE_VECTOR_ICON_PADDING);
learn_more_button_->SetBorder(views::CreatePaddedBorder(
views::CreateSolidSidedBorder(
gfx::Insets::TLBR(inset, 0, inset, inset),
color_provider->GetColor(ui::kColorButtonBackground)),
views::LayoutProvider::Get()->GetInsetsMetric(
views::INSETS_VECTOR_IMAGE_BUTTON)));
} else {
learn_more_button_->SetBorder(views::CreatePaddedBorder(
views::CreateSolidSidedBorder(
gfx::Insets::TLBR(
views::LayoutProvider::Get()->GetShadowElevationMetric(
views::Emphasis::kLow),
0, 0, 0),
color_provider->GetColor(ui::kColorBubbleFooterBorder)),
views::LayoutProvider::Get()->GetInsetsMetric(
views::INSETS_VECTOR_IMAGE_BUTTON)));
}
// TODO(crbug.com/1099044): Update and use cros colors.
learn_more_button_->SetImageModel(
views::Button::ButtonState::STATE_NORMAL,
ui::ImageModel::FromVectorIcon(vector_icons::kSettingsOutlineIcon,
ui::kColorIconSecondary));
}
SuggestionWindowView::SuggestionWindowView(gfx::NativeView parent,
AssistiveDelegate* delegate,
Orientation orientation)
: delegate_(delegate) {
DCHECK(parent);
// AccessibleRole determines whether the content is announced on pop-up.
// Inner content should not be announced when the window appears since this
// is handled by AssistiveAccessibilityView to announce a custom string.
SetAccessibleWindowRole(ax::mojom::Role::kNone);
SetButtons(static_cast<int>(ui::mojom::DialogButton::kNone));
SetCanActivate(false);
set_parent_window(parent);
set_margins(gfx::Insets());
set_adjust_if_offscreen(true);
completion_view_ = AddChildView(
std::make_unique<CompletionSuggestionView>(base::BindRepeating(
&AssistiveDelegate::AssistiveWindowButtonClicked,
base::Unretained(delegate_),
AssistiveWindowButton{.id = ui::ime::ButtonId::kSuggestion,
.suggestion_index = 0})));
completion_view_->SetVisible(false);
multiple_candidate_area_ = AddChildView(std::make_unique<views::View>());
multiple_candidate_area_->SetVisible(false);
Reorient(orientation);
setting_link_ = AddChildView(std::make_unique<views::Link>(
l10n_util::GetStringUTF16(IDS_SUGGESTION_LEARN_MORE)));
setting_link_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
// TODO(crbug.com/40138695): Implement proper UI layout using Insets constant.
constexpr auto insets = gfx::Insets::TLBR(0, kPadding, kPadding, kPadding);
setting_link_->SetBorder(views::CreateEmptyBorder(insets));
constexpr int kSettingLinkFontSize = 11;
setting_link_->SetFontList(gfx::FontList({kFontStyle}, gfx::Font::ITALIC,
kSettingLinkFontSize,
gfx::Font::Weight::NORMAL));
const auto on_setting_link_clicked = [](AssistiveDelegate* delegate) {
delegate->AssistiveWindowButtonClicked(
{.id = ButtonId::kSmartInputsSettingLink});
};
setting_link_->SetCallback(
base::BindRepeating(on_setting_link_clicked, delegate_));
setting_link_->SetVisible(false);
learn_more_button_ =
AddChildView(std::make_unique<views::ImageButton>(base::BindRepeating(
&SuggestionWindowView::LearnMoreClicked, base::Unretained(this))));
learn_more_button_->SetImageHorizontalAlignment(
views::ImageButton::ALIGN_CENTER);
learn_more_button_->SetImageVerticalAlignment(
views::ImageButton::ALIGN_MIDDLE);
learn_more_button_->SetTooltipText(l10n_util::GetStringUTF16(IDS_LEARN_MORE));
const auto update_button_highlight = [](views::Button* button) {
SetHighlighted(*button, ShouldHighlight(*button));
};
auto subscription =
learn_more_button_->AddStateChangedCallback(base::BindRepeating(
update_button_highlight, base::Unretained(learn_more_button_)));
subscriptions_.insert({learn_more_button_, std::move(subscription)});
learn_more_button_->SetVisible(false);
}
SuggestionWindowView::~SuggestionWindowView() = default;
void SuggestionWindowView::LearnMoreClicked() {
delegate_->AssistiveWindowButtonClicked(AssistiveWindowButton{
.id = ui::ime::ButtonId::kLearnMore, .window_type = type_});
}
raw_ptr<views::ImageButton> SuggestionWindowView::getLearnMoreButton() {
return learn_more_button_;
}
void SuggestionWindowView::ResizeCandidateArea(
const std::vector<std::u16string>& new_candidates,
bool use_legacy_candidate) {
const views::View::Views& candidates = multiple_candidate_area_->children();
while (candidates.size()) {
subscriptions_.erase(
multiple_candidate_area_->RemoveChildViewT(candidates.back()).get());
}
for (size_t index = 0; index < new_candidates.size(); ++index) {
auto* const candidate = multiple_candidate_area_->AddChildView(
std::make_unique<IndexedSuggestionCandidateButton>(
base::BindRepeating(
&AssistiveDelegate::AssistiveWindowButtonClicked,
base::Unretained(delegate_),
AssistiveWindowButton{.id = ui::ime::ButtonId::kSuggestion,
.suggestion_index = index}),
/* candidate_text=*/new_candidates[index],
// Label indexes start from "1", hence we increment index by one.
/* index_text=*/base::FormatNumber(index + 1),
use_legacy_candidate));
// TODO(crbug.com/40232718): See View::SetLayoutManagerUseConstrainedSpace.
candidate->SetLayoutManagerUseConstrainedSpace(false);
auto subscription = candidate->AddStateChangedCallback(base::BindRepeating(
[](SuggestionWindowView* window,
IndexedSuggestionCandidateButton* button) {
window->SetCandidateHighlighted(button, ShouldHighlight(*button));
},
base::Unretained(this), base::Unretained(candidate)));
subscriptions_.insert({candidate, std::move(subscription)});
}
}
void SuggestionWindowView::Reorient(Orientation orientation,
bool extra_padding_on_right) {
views::BoxLayout::Orientation layout_orientation =
views::BoxLayout::Orientation::kVertical;
int multiple_candidate_area_padding = 0;
switch (orientation) {
case Orientation::kVertical: {
layout_orientation = views::BoxLayout::Orientation::kVertical;
// TODO(jhtin): remove this when emoji uses horizontal layout.
multiple_candidate_area_padding = 0;
break;
}
case Orientation::kHorizontal: {
layout_orientation = views::BoxLayout::Orientation::kHorizontal;
multiple_candidate_area_padding = 4;
break;
}
}
SetLayoutManager(std::make_unique<views::BoxLayout>(layout_orientation));
gfx::Insets inset(multiple_candidate_area_padding);
if (!extra_padding_on_right) {
inset.set_right(0);
}
multiple_candidate_area_->SetLayoutManager(std::make_unique<views::BoxLayout>(
layout_orientation, inset,
/* between_child_spacing=*/multiple_candidate_area_padding));
}
void SuggestionWindowView::MakeVisible() {
multiple_candidate_area_->SetVisible(true);
SizeToContents();
// Docs can put the cursor offscreen - force it onscreen.
GetWidget()->SetBoundsConstrained(GetBubbleBounds());
}
void SuggestionWindowView::SetCandidateHighlighted(
IndexedSuggestionCandidateButton* view,
bool highlighted) {
// Clear all highlights if any exists.
for (views::View* candidate_button : multiple_candidate_area_->children()) {
static_cast<IndexedSuggestionCandidateButton*>(candidate_button)
->SetHighlight(false);
}
if (highlighted) {
view->SetHighlight(highlighted);
}
}
BEGIN_METADATA(SuggestionWindowView)
END_METADATA
} // namespace ime
} // namespace ui
Codebase Browser
chromium