| // Copyright 2013 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/native_theme/native_theme_mac.h" |
| |
| #include <CoreFoundation/CoreFoundation.h> |
| #include <MediaAccessibility/MediaAccessibility.h> |
| |
| #include <algorithm> |
| #include <array> |
| #include <optional> |
| #include <variant> |
| #include <vector> |
| |
| #include "base/numerics/safe_conversions.h" |
| #include "cc/paint/paint_canvas.h" |
| #include "cc/paint/paint_flags.h" |
| #include "cc/paint/paint_shader.h" |
| #include "third_party/skia/include/core/SkColor.h" |
| #include "third_party/skia/include/core/SkPoint.h" |
| #include "third_party/skia/include/core/SkScalar.h" |
| #include "third_party/skia/include/core/SkTileMode.h" |
| #include "ui/color/color_id.h" |
| #include "ui/color/color_provider.h" |
| #include "ui/gfx/canvas.h" |
| #include "ui/gfx/color_utils.h" |
| #include "ui/gfx/geometry/insets.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/gfx/geometry/skia_conversions.h" |
| #include "ui/native_theme/native_theme.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| bool IsHorizontal(NativeTheme::ScrollbarOrientation orientation) { |
| return orientation == NativeTheme::ScrollbarOrientation::kHorizontal; |
| } |
| |
| int ScrollbarTrackBorderWidth(float scale_factor) { |
| constexpr int kBorderWidth = 1; |
| return base::ClampFloor(kBorderWidth * scale_factor); |
| } |
| |
| void ConstrainInsets(int old_width, int min_width, int* left, int* right) { |
| const int requested_total_inset = *left + *right; |
| if (requested_total_inset == 0) { |
| return; |
| } |
| const int max_total_inset = old_width - min_width; |
| if (requested_total_inset < max_total_inset) { |
| return; |
| } |
| if (max_total_inset < 0) { |
| *left = *right = 0; |
| return; |
| } |
| // Multiply the right/bottom inset by the ratio by which we need to shrink the |
| // total inset. This has the effect of rounding down the right/bottom inset, |
| // if the two sides are to be affected unevenly. |
| // This is done instead of using inset scale functions to maintain expected |
| // behavior and to map to how it looks like other scrollbars work on MacOS. |
| *right *= max_total_inset * 1.0f / requested_total_inset; |
| *left = max_total_inset - *right; |
| } |
| |
| void CaptionSettingsChangedNotificationCallback(CFNotificationCenterRef, |
| void*, |
| CFStringRef, |
| const void*, |
| CFDictionaryRef) { |
| NativeTheme::GetInstanceForWeb()->NotifyOnCaptionStyleUpdated(); |
| } |
| |
| // These functions are called from the renderer process through the scrollbar |
| // drawing functions. Due to this, they cannot use any of the dynamic NS system |
| // colors. |
| // TODO(pkasting): Consider whether these colors should instead go in a |
| // Mac-specific color mixer, which would mean scrollbars in web content would |
| // get these colors instead of Aura defaults. |
| |
| SkColor GetMacScrollbarThumbColor( |
| bool dark_mode, |
| const NativeTheme::ScrollbarExtraParams& extra_params) { |
| if (extra_params.thumb_color.has_value()) { |
| return extra_params.thumb_color.value(); |
| } |
| if (extra_params.is_overlay) { |
| return dark_mode ? SkColorSetARGB(0x80, 0xFF, 0xFF, 0xFF) |
| : SkColorSetARGB(0x80, 0, 0, 0); |
| } |
| if (extra_params.is_hovering) { |
| return dark_mode ? SkColorSetRGB(0x93, 0x93, 0x93) |
| : SkColorSetARGB(0x80, 0, 0, 0); |
| } |
| return dark_mode ? SkColorSetRGB(0x6B, 0x6B, 0x6B) |
| : SkColorSetARGB(0x3A, 0, 0, 0); |
| } |
| |
| template <bool inner_border> |
| SkColor GetMacScrollbarTrackBorderColor( |
| bool dark_mode, |
| const NativeTheme::ScrollbarExtraParams& extra_params) { |
| if (extra_params.track_color.has_value()) { |
| return extra_params.track_color.value(); |
| } |
| if constexpr (inner_border) { |
| if (extra_params.is_overlay) { |
| return dark_mode ? SkColorSetARGB(0x33, 0xE5, 0xE5, 0xE5) |
| : SkColorSetARGB(0xF9, 0xDF, 0xDF, 0xDF); |
| } |
| return dark_mode ? SkColorSetRGB(0x3D, 0x3D, 0x3D) |
| : SkColorSetRGB(0xE8, 0xE8, 0xE8); |
| } else { |
| if (extra_params.is_overlay) { |
| return dark_mode ? SkColorSetARGB(0x28, 0xD8, 0xD8, 0xD8) |
| : SkColorSetARGB(0xC6, 0xE8, 0xE8, 0xE8); |
| } |
| return dark_mode ? SkColorSetRGB(0x51, 0x51, 0x51) |
| : SkColorSetRGB(0xED, 0xED, 0xED); |
| } |
| } |
| |
| void PaintMacScrollbarThumb( |
| cc::PaintCanvas* canvas, |
| NativeTheme::Part part, |
| NativeTheme::State state, |
| const gfx::Rect& rect, |
| const NativeTheme::ScrollbarExtraParams& extra_params, |
| bool dark_mode) { |
| // Compute the bounds for the rounded rect for the thumb from the bounds of |
| // the thumb. |
| gfx::Rect bounds(rect); |
| { |
| // Shrink the thumb evenly in length and girth to fit within the track. |
| const int base_inset = base::ClampRound((extra_params.is_overlay ? 2 : 3) * |
| extra_params.scale_from_dip); |
| int inset_left = base_inset, inset_right = base_inset, |
| inset_top = base_inset, inset_bottom = base_inset; |
| |
| // Also shrink the thumb in girth to not touch the border. |
| const bool horizontal = IsHorizontal(extra_params.orientation); |
| (horizontal ? inset_top : inset_left) += |
| ScrollbarTrackBorderWidth(extra_params.scale_from_dip); |
| |
| const gfx::Size min_size = NativeThemeMac::GetThumbMinSize( |
| horizontal, extra_params.scale_from_dip); |
| ConstrainInsets(bounds.width(), min_size.width(), &inset_left, |
| &inset_right); |
| ConstrainInsets(bounds.height(), min_size.height(), &inset_top, |
| &inset_bottom); |
| bounds.Inset( |
| gfx::Insets::TLBR(inset_top, inset_left, inset_bottom, inset_right)); |
| } |
| |
| const SkScalar radius = std::min(bounds.width(), bounds.height()); |
| |
| cc::PaintFlags flags; |
| flags.setAntiAlias(true); |
| flags.setColor(GetMacScrollbarThumbColor(dark_mode, extra_params)); |
| gfx::Canvas(canvas, 1.0f).DrawRoundRect(bounds, radius, flags); |
| } |
| |
| void PaintScrollBarTrackGradient( |
| cc::PaintCanvas* canvas, |
| const gfx::Rect& rect, |
| const NativeTheme::ScrollbarExtraParams& extra_params, |
| bool is_corner, |
| bool dark_mode) { |
| cc::PaintFlags flags; |
| if (extra_params.track_color.has_value()) { |
| flags.setAntiAlias(true); |
| flags.setColor(extra_params.track_color.value()); |
| } else { |
| // Set the gradient direction. |
| std::array<SkPoint, 2> gradient_bounds; |
| const SkPoint origin = gfx::PointToSkPoint(rect.origin()); |
| if (is_corner) { |
| if (extra_params.orientation == |
| NativeTheme::ScrollbarOrientation::kVerticalOnRight) { |
| gradient_bounds = {origin, gfx::PointToSkPoint(rect.bottom_right())}; |
| } else { |
| gradient_bounds = {gfx::PointToSkPoint(rect.top_right()), |
| gfx::PointToSkPoint(rect.bottom_left())}; |
| } |
| } else { |
| if (IsHorizontal(extra_params.orientation)) { |
| gradient_bounds = {origin, gfx::PointToSkPoint(rect.top_right())}; |
| } else { |
| gradient_bounds = {origin, gfx::PointToSkPoint(rect.bottom_left())}; |
| } |
| } |
| |
| // Select colors. |
| std::vector<SkColor4f> gradient_colors; |
| if (extra_params.is_overlay) { |
| if (dark_mode) { |
| gradient_colors = {SkColor4f{0.847f, 0.847f, 0.847f, 0.157f}, |
| SkColor4f{0.8f, 0.8f, 0.8f, 0.149f}, |
| SkColor4f{0.8f, 0.8f, 0.8f, 0.149f}, |
| SkColor4f{0.8f, 0.8f, 0.8f, 0.149f}}; |
| } else { |
| gradient_colors = {SkColor4f{0.973f, 0.973f, 0.973f, 0.776f}, |
| SkColor4f{0.973f, 0.973f, 0.973f, 0.761f}, |
| SkColor4f{0.973f, 0.973f, 0.973f, 0.761f}, |
| SkColor4f{0.973f, 0.973f, 0.973f, 0.761f}}; |
| } |
| } else { |
| // On Safari non-overlay scrollbar track colors are transparent, but on |
| // all other macOS applications they are not. |
| if (dark_mode) { |
| gradient_colors = {SkColor4f{0.176f, 0.176f, 0.176f, 1.0f}, |
| SkColor4f{0.169f, 0.169f, 0.169f, 1.0f}}; |
| } else { |
| gradient_colors = {SkColor4f{0.98f, 0.98f, 0.98f, 1.0f}, |
| SkColor4f{0.98f, 0.98f, 0.98f, 1.0f}}; |
| } |
| } |
| |
| flags.setShader(cc::PaintShader::MakeLinearGradient( |
| gradient_bounds.data(), gradient_colors.data(), nullptr, |
| gradient_colors.size(), SkTileMode::kClamp)); |
| } |
| |
| gfx::Canvas(canvas, 1.0f).DrawRect(rect, flags); |
| } |
| |
| void PaintScrollbarTrackInnerBorder( |
| cc::PaintCanvas* canvas, |
| const gfx::Rect& rect, |
| const NativeTheme::ScrollbarExtraParams& extra_params, |
| bool is_corner, |
| bool dark_mode) { |
| // Compute the rect for the border. |
| gfx::Rect inner_border(rect); |
| const int border_width = |
| ScrollbarTrackBorderWidth(extra_params.scale_from_dip); |
| if (extra_params.orientation == |
| NativeTheme::ScrollbarOrientation::kVerticalOnLeft) { |
| inner_border.set_x(rect.right() - border_width); |
| } |
| const bool horizontal = IsHorizontal(extra_params.orientation); |
| if (is_corner || horizontal) { |
| inner_border.set_height(border_width); |
| } |
| if (is_corner || !horizontal) { |
| inner_border.set_width(border_width); |
| } |
| |
| cc::PaintFlags flags; |
| flags.setColor( |
| GetMacScrollbarTrackBorderColor<true>(dark_mode, extra_params)); |
| gfx::Canvas(canvas, 1.0f).DrawRect(inner_border, flags); |
| } |
| |
| void PaintScrollbarTrackOuterBorder( |
| cc::PaintCanvas* canvas, |
| const gfx::Rect& rect, |
| const NativeTheme::ScrollbarExtraParams& extra_params, |
| bool is_corner, |
| bool dark_mode) { |
| gfx::Canvas paint_canvas(canvas, 1.0f); |
| |
| cc::PaintFlags flags; |
| flags.setColor( |
| GetMacScrollbarTrackBorderColor<false>(dark_mode, extra_params)); |
| |
| // Draw the horizontal outer border. |
| const bool horizontal = IsHorizontal(extra_params.orientation); |
| const int border_width = |
| ScrollbarTrackBorderWidth(extra_params.scale_from_dip); |
| if (is_corner || horizontal) { |
| gfx::Rect outer_border(rect); |
| outer_border.set_y(rect.bottom() - border_width); |
| outer_border.set_height(border_width); |
| paint_canvas.DrawRect(outer_border, flags); |
| } |
| |
| // Draw the vertical outer border. |
| if (is_corner || !horizontal) { |
| gfx::Rect outer_border(rect); |
| if (extra_params.orientation == |
| NativeTheme::ScrollbarOrientation::kVerticalOnRight) { |
| outer_border.set_x(rect.right() - border_width); |
| } |
| outer_border.set_width(border_width); |
| paint_canvas.DrawRect(outer_border, flags); |
| } |
| } |
| |
| void PaintMacScrollBarTrackOrCorner( |
| cc::PaintCanvas* canvas, |
| const NativeTheme::ScrollbarExtraParams& extra_params, |
| const gfx::Rect& rect, |
| bool dark_mode, |
| bool is_corner) { |
| if (is_corner && extra_params.is_overlay) { |
| return; |
| } |
| PaintScrollBarTrackGradient(canvas, rect, extra_params, is_corner, dark_mode); |
| PaintScrollbarTrackInnerBorder(canvas, rect, extra_params, is_corner, |
| dark_mode); |
| PaintScrollbarTrackOuterBorder(canvas, rect, extra_params, is_corner, |
| dark_mode); |
| } |
| |
| } // namespace |
| |
| // static |
| gfx::Size NativeThemeMac::GetThumbMinSize(bool horizontal, float scale) { |
| gfx::Size size = gfx::ScaleToRoundedSize({6, 18}, scale); |
| if (horizontal) { |
| size.Transpose(); |
| } |
| return size; |
| } |
| |
| SkColor NativeThemeMac::GetSystemButtonPressedColor(SkColor base_color) const { |
| // Mac has a different "pressed button" styling because it doesn't use |
| // ripples. |
| // TODO(crbug.com/40098660): This should probably be replaced with a color |
| // transform. |
| return color_utils::GetResultingPaintColor(SkColorSetA(SK_ColorBLACK, 0x10), |
| base_color); |
| } |
| |
| void NativeThemeMac::PaintMenuItemBackground( |
| cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| State state, |
| const gfx::Rect& rect, |
| const MenuItemExtraParams& extra_params) const { |
| if (state != kHovered) { |
| return; |
| } |
| |
| CHECK(color_provider); |
| cc::PaintFlags flags; |
| flags.setAntiAlias(true); |
| flags.setColor(color_provider->GetColor(kColorMenuItemBackgroundSelected)); |
| const SkScalar radius = SkIntToScalar(extra_params.corner_radius); |
| canvas->drawRoundRect(gfx::RectToSkRect(rect), radius, radius, flags); |
| } |
| |
| NativeThemeMac::NativeThemeMac() { |
| if (static bool initialized = false; !initialized) { |
| // Observe caption style changes. Technically these notify the web instance |
| // rather than `this`, but there's a 1:1 relationship between the two, and |
| // putting this code here allows simpler cross-platform |
| // `GetInstanceFor...()` implementations. |
| CFNotificationCenterAddObserver( |
| CFNotificationCenterGetLocalCenter(), nullptr, |
| CaptionSettingsChangedNotificationCallback, |
| kMACaptionAppearanceSettingsChangedNotification, nullptr, |
| CFNotificationSuspensionBehaviorDeliverImmediately); |
| initialized = true; |
| } |
| } |
| |
| NativeThemeMac::~NativeThemeMac() = default; |
| |
| void NativeThemeMac::PaintImpl(cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| Part part, |
| State state, |
| const gfx::Rect& rect, |
| const ExtraParams& extra_params, |
| bool forced_colors, |
| bool dark_mode, |
| PreferredContrast contrast, |
| std::optional<SkColor> accent_color) const { |
| // Mac uses bespoke scrollbar painting methods (instead of simply overriding |
| // the parent ones) in order to pass `ScrollbarExtraParams`, which doesn't |
| // exist on other platforms. |
| if (part == kScrollbarHorizontalThumb || part == kScrollbarVerticalThumb) { |
| PaintMacScrollbarThumb(canvas, part, state, rect, |
| std::get<ScrollbarExtraParams>(extra_params), |
| dark_mode); |
| return; |
| } |
| if (part == kScrollbarHorizontalTrack || part == kScrollbarVerticalTrack || |
| part == kScrollbarCorner) { |
| PaintMacScrollBarTrackOrCorner(canvas, |
| std::get<ScrollbarExtraParams>(extra_params), |
| rect, dark_mode, part == kScrollbarCorner); |
| return; |
| } |
| |
| NativeThemeBase::PaintImpl(canvas, color_provider, part, state, rect, |
| extra_params, forced_colors, dark_mode, contrast, |
| accent_color); |
| } |
| |
| void NativeThemeMac::PaintMenuPopupBackground( |
| cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| const gfx::Size& size, |
| const MenuBackgroundExtraParams& extra_params) const { |
| CHECK(color_provider); |
| cc::PaintFlags flags; |
| flags.setAntiAlias(true); |
| flags.setColor(color_provider->GetColor(kColorMenuBackground)); |
| const SkScalar radius = SkIntToScalar(extra_params.corner_radius); |
| canvas->drawRoundRect(gfx::RectToSkRect(gfx::Rect(size)), radius, radius, |
| flags); |
| } |
| |
| } // namespace ui |
