// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ui/frame/multitask_menu/split_button_view.h"
#include <memory>
#include "chromeos/strings/grit/chromeos_strings.h"
#include "chromeos/ui/frame/frame_utils.h"
#include "chromeos/utils/haptics_util.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/events/devices/haptic_touchpad_effects.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/color_palette.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/controls/highlight_path_generator.h"
namespace chromeos {
namespace {
constexpr int kMultitaskHalfButtonWidth = 54;
constexpr int kMultitaskHalfButtonHeight = 72;
constexpr int kMultitaskOneThirdButtonWidth = 38;
constexpr int kMultitaskTwoThirdButtonWidth = 70;
// The preferred insets would be 4 on each side.
constexpr gfx::Insets kPreferredInsets(4);
// The two buttons share an edge so the inset on both sides needs to be halved
// so that visually we get the preferred insets above.
constexpr gfx::Insets kLeftButtonInsets = gfx::Insets::TLBR(4, 4, 4, 2);
constexpr gfx::Insets kTopButtonInsets = gfx::Insets::TLBR(4, 4, 2, 4);
constexpr gfx::Insets kRightButtonInsets = gfx::Insets::TLBR(4, 2, 4, 4);
constexpr gfx::Insets kBottomButtonInsets = gfx::Insets::TLBR(2, 4, 4, 4);
bool IsHoveredOrPressedState(views::Button::ButtonState button_state) {
return button_state == views::Button::STATE_PRESSED ||
button_state == views::Button::STATE_HOVERED;
}
// Gets the string for the direction (top/bottom/left/right) of the split
// button. Used in various for a11y names.
std::u16string GetDirectionString(bool left_top, bool portrait_mode) {
int message_id;
if (left_top) {
message_id =
portrait_mode ? IDS_MULTITASK_MENU_TOP : IDS_MULTITASK_MENU_LEFT;
} else {
// Right or bottom.
message_id =
portrait_mode ? IDS_MULTITASK_MENU_BOTTOM : IDS_MULTITASK_MENU_RIGHT;
}
return l10n_util::GetStringUTF16(message_id);
}
std::u16string GetA11yName(SplitButtonView::SplitButtonType type,
bool left_top,
bool portrait_mode) {
int template_id;
switch (type) {
case SplitButtonView::SplitButtonType::kHalfButtons:
template_id = IDS_MULTITASK_MENU_HALF_BUTTON_ACCESSIBLE_NAME;
break;
case SplitButtonView::SplitButtonType::kPartialButtons:
// Left/top button is always the larger one.
template_id =
left_top ? IDS_MULTITASK_MENU_PARTIAL_BUTTON_LARGE_ACCESSIBLE_NAME
: IDS_MULTITASK_MENU_PARTIAL_BUTTON_SMALL_ACCESSIBLE_NAME;
break;
}
return l10n_util::GetStringFUTF16(
template_id, GetDirectionString(left_top, portrait_mode));
}
} // namespace
// -----------------------------------------------------------------------------
// SplitButton:
// A button used for SplitButtonView to trigger snapping.
class SplitButtonView::SplitButton : public views::Button {
METADATA_HEADER(SplitButton, views::Button)
public:
SplitButton(views::Button::PressedCallback pressed_callback,
base::RepeatingClosure hovered_pressed_callback,
const gfx::Insets& insets)
: views::Button(std::move(pressed_callback)),
insets_(insets),
hovered_pressed_callback_(std::move(hovered_pressed_callback)) {
// Subtract by the preferred insets so that the focus ring is drawn around
// the painted region below. Also, use the parent's rounded radius so the
// ring matches the parent border.
views::InstallRoundRectHighlightPathGenerator(
this, insets - kPreferredInsets, kMultitaskBaseButtonBorderRadius);
}
SplitButton(const SplitButton&) = delete;
SplitButton& operator=(const SplitButton&) = delete;
~SplitButton() override = default;
void set_button_color(SkColor color) { button_color_ = color; }
// views::Button:
void StateChanged(views::Button::ButtonState old_state) override {
if (GetState() == views::Button::STATE_HOVERED) {
haptics_util::PlayHapticTouchpadEffect(
ui::HapticTouchpadEffect::kSnap,
ui::HapticTouchpadEffectStrength::kMedium);
}
if (IsHoveredOrPressedState(old_state) ||
IsHoveredOrPressedState(GetState())) {
hovered_pressed_callback_.Run();
}
}
void OnPaintBackground(gfx::Canvas* canvas) override {
cc::PaintFlags pattern_flags;
pattern_flags.setAntiAlias(true);
pattern_flags.setColor(
GetEnabled()
? button_color_
: SkColorSetA(GetColorProvider()->GetColor(ui::kColorSysOnSurface),
kMultitaskDisabledButtonOpacity));
pattern_flags.setStyle(cc::PaintFlags::kFill_Style);
gfx::Rect pattern_bounds = GetLocalBounds();
pattern_bounds.Inset(insets_);
canvas->DrawRoundRect(pattern_bounds, kButtonCornerRadius, pattern_flags);
}
private:
SkColor button_color_ = SK_ColorTRANSPARENT;
// The inset between the button window pattern and the border.
gfx::Insets insets_;
// Callback to `SplitButtonView` to change button color. When one split button
// is hovered or pressed, both split buttons on `SplitButtonView` change
// color.
base::RepeatingClosure hovered_pressed_callback_;
};
BEGIN_METADATA(SplitButtonView, SplitButton)
END_METADATA
// -----------------------------------------------------------------------------
// SplitButtonView:
SplitButtonView::SplitButtonView(SplitButtonType type,
SplitButtonCallback split_button_callback,
aura::Window* window,
bool is_portrait_mode)
: type_(type) {
// Left button should stay on the left side for RTL languages.
SetMirrored(false);
SetOrientation(is_portrait_mode ? views::BoxLayout::Orientation::kVertical
: views::BoxLayout::Orientation::kHorizontal);
auto on_hover_pressed = base::BindRepeating(
&SplitButtonView::OnButtonHoveredOrPressed, base::Unretained(this));
const SnapDirection left_top_direction =
GetSnapDirectionForWindow(window, /*left_top=*/true);
const SnapDirection right_bottom_direction =
GetSnapDirectionForWindow(window, /*left_top=*/false);
auto on_left_top_press =
base::BindRepeating(split_button_callback, left_top_direction);
auto on_right_bottom_press =
base::BindRepeating(split_button_callback, right_bottom_direction);
left_top_button_ = AddChildView(std::make_unique<SplitButton>(
on_left_top_press, on_hover_pressed,
is_portrait_mode ? kTopButtonInsets : kLeftButtonInsets));
right_bottom_button_ = AddChildView(std::make_unique<SplitButton>(
on_right_bottom_press, on_hover_pressed,
is_portrait_mode ? kBottomButtonInsets : kRightButtonInsets));
UpdateButtons(is_portrait_mode, /*is_reversed=*/false);
}
void SplitButtonView::UpdateButtons(bool is_portrait_mode, bool is_reversed) {
const int left_top_width =
type_ == SplitButtonType::kHalfButtons
? kMultitaskHalfButtonWidth
: (is_reversed ? kMultitaskOneThirdButtonWidth
: kMultitaskTwoThirdButtonWidth);
const int right_bottom_width =
type_ == SplitButtonType::kHalfButtons
? kMultitaskHalfButtonWidth
: (is_reversed ? kMultitaskTwoThirdButtonWidth
: kMultitaskOneThirdButtonWidth);
left_top_button_->SetPreferredSize(
is_portrait_mode ? gfx::Size(kMultitaskHalfButtonHeight, left_top_width)
: gfx::Size(left_top_width, kMultitaskHalfButtonHeight));
right_bottom_button_->SetPreferredSize(
is_portrait_mode
? gfx::Size(kMultitaskHalfButtonHeight, right_bottom_width)
: gfx::Size(right_bottom_width, kMultitaskHalfButtonHeight));
left_top_button_->GetViewAccessibility().SetName(
GetA11yName(type_, /*left_top=*/!is_reversed, is_portrait_mode));
right_bottom_button_->GetViewAccessibility().SetName(
GetA11yName(type_, /*left_top=*/is_reversed, is_portrait_mode));
}
views::Button* SplitButtonView::GetLeftTopButton() {
return left_top_button_;
}
views::Button* SplitButtonView::GetRightBottomButton() {
return right_bottom_button_;
}
void SplitButtonView::OnButtonHoveredOrPressed() {
const auto* color_provider = GetColorProvider();
const SkColor primary_hover_color =
color_provider->GetColor(ui::kColorSysPrimary);
border_color_ = primary_hover_color;
const SkColor secondary_hover_color =
SkColorSetA(primary_hover_color, kMultitaskHoverButtonOpacity);
fill_color_ =
SkColorSetA(primary_hover_color, kMultitaskHoverBackgroundOpacity);
if (IsHoveredOrPressedState(right_bottom_button_->GetState())) {
right_bottom_button_->set_button_color(primary_hover_color);
left_top_button_->set_button_color(secondary_hover_color);
} else if (IsHoveredOrPressedState(left_top_button_->GetState())) {
left_top_button_->set_button_color(primary_hover_color);
right_bottom_button_->set_button_color(secondary_hover_color);
} else {
// Reset color.
fill_color_ = SK_ColorTRANSPARENT;
border_color_ =
SkColorSetA(color_provider->GetColor(ui::kColorSysOnSurface),
kMultitaskDefaultButtonOpacity);
right_bottom_button_->set_button_color(border_color_);
left_top_button_->set_button_color(border_color_);
}
SchedulePaint();
}
void SplitButtonView::OnPaint(gfx::Canvas* canvas) {
gfx::RectF bounds(GetLocalBounds());
cc::PaintFlags fill_flags;
fill_flags.setStyle(cc::PaintFlags::kFill_Style);
fill_flags.setColor(fill_color_);
canvas->DrawRoundRect(bounds, kMultitaskBaseButtonBorderRadius, fill_flags);
// Inset by half the stroke width, otherwise half of the stroke will be out of
// bounds.
bounds.Inset(kButtonBorderSize / 2.f);
cc::PaintFlags border_flags;
border_flags.setAntiAlias(true);
border_flags.setStyle(cc::PaintFlags::kStroke_Style);
border_flags.setColor(border_color_);
border_flags.setStrokeWidth(kButtonBorderSize);
canvas->DrawRoundRect(bounds, kMultitaskBaseButtonBorderRadius, border_flags);
}
void SplitButtonView::OnThemeChanged() {
views::View::OnThemeChanged();
border_color_ =
SkColorSetA(GetColorProvider()->GetColor(ui::kColorSysOnSurface),
kMultitaskDefaultButtonOpacity);
right_bottom_button_->set_button_color(border_color_);
left_top_button_->set_button_color(border_color_);
}
BEGIN_METADATA(SplitButtonView)
END_METADATA
} // namespace chromeos
Codebase Browser
chromium