| // Copyright 2012 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_win.h" |
| |
| #include <windows.h> |
| |
| #include <stddef.h> |
| #include <uxtheme.h> |
| #include <vsstyle.h> |
| |
| #include <array> |
| #include <cmath> |
| #include <optional> |
| #include <utility> |
| #include <variant> |
| |
| #include "base/check.h" |
| #include "base/compiler_specific.h" |
| #include "base/containers/fixed_flat_map.h" |
| #include "base/containers/flat_map.h" |
| #include "base/containers/span.h" |
| #include "base/no_destructor.h" |
| #include "base/notreached.h" |
| #include "base/numerics/checked_math.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/strings/cstring_view.h" |
| #include "base/win/scoped_gdi_object.h" |
| #include "base/win/scoped_hdc.h" |
| #include "base/win/scoped_select_object.h" |
| #include "base/win/win_util.h" |
| #include "cc/paint/paint_canvas.h" |
| #include "cc/paint/paint_flags.h" |
| #include "skia/ext/skia_utils_win.h" |
| #include "third_party/skia/include/core/SkBitmap.h" |
| #include "third_party/skia/include/core/SkBlendMode.h" |
| #include "third_party/skia/include/core/SkCanvas.h" |
| #include "third_party/skia/include/core/SkColor.h" |
| #include "third_party/skia/include/core/SkImageInfo.h" |
| #include "third_party/skia/include/core/SkMatrix.h" |
| #include "third_party/skia/include/core/SkPaint.h" |
| #include "third_party/skia/include/core/SkPath.h" |
| #include "third_party/skia/include/core/SkRefCnt.h" |
| #include "third_party/skia/include/core/SkSamplingOptions.h" |
| #include "third_party/skia/include/core/SkScalar.h" |
| #include "third_party/skia/include/core/SkSurface.h" |
| #include "third_party/skia/include/core/SkTileMode.h" |
| #include "third_party/skia/include/private/chromium/SkPMColor.h" |
| #include "ui/color/color_id.h" |
| #include "ui/color/color_provider.h" |
| #include "ui/display/win/screen_win.h" |
| #include "ui/gfx/geometry/point_f.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/geometry/rect_f.h" |
| #include "ui/gfx/geometry/skia_conversions.h" |
| #include "ui/native_theme/native_theme.h" |
| #include "ui/native_theme/os_settings_provider.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| using ThemeHandles = base::flat_map<base::wcstring_view, HANDLE>; |
| |
| void SetCheckerboardShader(SkPaint* paint, int left, int top) { |
| // Create a 2x2 checkerboard pattern using the 3D face and highlight colors. |
| const auto& os_settings_provider = OsSettingsProvider::Get(); |
| using enum OsSettingsProvider::ColorId; |
| const SkColor face = os_settings_provider.Color(kButtonFace) |
| .value_or(SkColorSetRGB(0xC0, 0xC0, 0xC0)); |
| const SkColor highlight = |
| os_settings_provider.Color(kButtonHighlight).value_or(SK_ColorWHITE); |
| SkColor buffer[] = {face, highlight, highlight, face}; |
| // Confusing bit: we first create a temporary bitmap with our desired pattern, |
| // then copy it to another bitmap. The temporary bitmap doesn't take |
| // ownership of the pixel data, and so will point to garbage when this |
| // function returns. The copy will copy the pixel data into a place owned by |
| // the bitmap, which is in turn owned by the shader, etc., so it will live |
| // until we're done using it. |
| SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2); |
| SkBitmap temp_bitmap; |
| temp_bitmap.installPixels(info, buffer, info.minRowBytes()); |
| SkBitmap bitmap; |
| if (bitmap.tryAllocPixels(info)) { |
| temp_bitmap.readPixels(info, bitmap.getPixels(), bitmap.rowBytes(), 0, 0); |
| } |
| |
| // Align the pattern with the upper corner of |align_rect|. |
| SkMatrix local_matrix; |
| local_matrix.setTranslate(SkIntToScalar(left), SkIntToScalar(top)); |
| paint->setShader(bitmap.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, |
| SkSamplingOptions(), &local_matrix)); |
| } |
| |
| // Custom scoped object for storing DC and a bitmap that was selected into it, |
| // and making sure that they are deleted in the right order. |
| class ScopedCreateDCWithBitmap { |
| public: |
| explicit ScopedCreateDCWithBitmap(base::win::ScopedCreateDC::Handle hdc) |
| : dc_(hdc) {} |
| |
| ScopedCreateDCWithBitmap(const ScopedCreateDCWithBitmap&) = delete; |
| ScopedCreateDCWithBitmap& operator=(const ScopedCreateDCWithBitmap&) = delete; |
| |
| ~ScopedCreateDCWithBitmap() { |
| // Delete DC before the bitmap, since objects should not be deleted while |
| // selected into a DC. |
| dc_.Close(); |
| } |
| |
| bool IsValid() const { return dc_.is_valid(); } |
| |
| base::win::ScopedCreateDC::Handle Get() const { return dc_.Get(); } |
| |
| // Selects |handle| to bitmap into DC. Returns false if handle is not valid. |
| bool SelectBitmap(HBITMAP handle) { |
| bitmap_.reset(handle); |
| if (!bitmap_.is_valid()) { |
| return false; |
| } |
| |
| SelectObject(dc_.Get(), bitmap_.get()); |
| return true; |
| } |
| |
| private: |
| base::win::ScopedCreateDC dc_; |
| base::win::ScopedGDIObject<HBITMAP> bitmap_; |
| }; |
| |
| // Returns the cached open theme handles. This is process-scoped rather than |
| // owned by `NativeThemeWin` so that, in case two `NativeThemeWin` instances are |
| // live simultaneously (e.g. in tests), destroying one (and thus calling |
| // `CloseThemeData()` on all its handles) won't leave the other holding invalid |
| // handles. |
| ThemeHandles* GetThemeHandles() { |
| static base::NoDestructor<ThemeHandles> kThemeHandles; |
| return kThemeHandles.get(); |
| } |
| |
| // Returns the theme handle for `part`, opening it if necessary. |
| HANDLE GetThemeHandle(NativeTheme::Part part) { |
| base::wcstring_view theme_class; |
| switch (part) { |
| case NativeTheme::kCheckbox: |
| case NativeTheme::kPushButton: |
| case NativeTheme::kRadio: |
| theme_class = L"Button"; |
| break; |
| case NativeTheme::kMenuList: |
| case NativeTheme::kMenuCheck: |
| case NativeTheme::kMenuCheckBackground: |
| case NativeTheme::kMenuPopupArrow: |
| case NativeTheme::kMenuPopupGutter: |
| case NativeTheme::kMenuPopupSeparator: |
| theme_class = L"Menu"; |
| break; |
| case NativeTheme::kProgressBar: |
| theme_class = L"Progress"; |
| break; |
| case NativeTheme::kScrollbarDownArrow: |
| case NativeTheme::kScrollbarLeftArrow: |
| case NativeTheme::kScrollbarRightArrow: |
| case NativeTheme::kScrollbarUpArrow: |
| case NativeTheme::kScrollbarHorizontalGripper: |
| case NativeTheme::kScrollbarVerticalGripper: |
| case NativeTheme::kScrollbarHorizontalThumb: |
| case NativeTheme::kScrollbarVerticalThumb: |
| case NativeTheme::kScrollbarHorizontalTrack: |
| case NativeTheme::kScrollbarVerticalTrack: |
| theme_class = OsSettingsProvider::Get().DarkColorSchemeAvailable() |
| ? base::wcstring_view(L"Explorer::Scrollbar") |
| : base::wcstring_view(L"Scrollbar"); |
| break; |
| case NativeTheme::kInnerSpinButton: |
| theme_class = L"Spin"; |
| break; |
| case NativeTheme::kWindowResizeGripper: |
| theme_class = L"Status"; |
| break; |
| case NativeTheme::kTabPanelBackground: |
| theme_class = L"Tab"; |
| break; |
| case NativeTheme::kTextField: |
| theme_class = L"Edit"; |
| break; |
| case NativeTheme::kTrackbarThumb: |
| case NativeTheme::kTrackbarTrack: |
| theme_class = L"Trackbar"; |
| break; |
| default: |
| NOTREACHED(); |
| } |
| |
| HANDLE& handle = (*GetThemeHandles())[theme_class]; |
| if (!handle) { |
| handle = OpenThemeData(nullptr, theme_class.c_str()); |
| } |
| return handle; |
| } |
| |
| int GetWindowsPart(NativeTheme::Part part, |
| const NativeTheme::ExtraParams& extra_params) { |
| if (part == NativeTheme::kScrollbarHorizontalTrack) { |
| return std::get<NativeTheme::ScrollbarTrackExtraParams>(extra_params) |
| .is_upper |
| ? SBP_UPPERTRACKHORZ |
| : SBP_LOWERTRACKHORZ; |
| } |
| if (part == NativeTheme::kScrollbarVerticalTrack) { |
| return std::get<NativeTheme::ScrollbarTrackExtraParams>(extra_params) |
| .is_upper |
| ? SBP_UPPERTRACKVERT |
| : SBP_LOWERTRACKVERT; |
| } |
| if (part == NativeTheme::kInnerSpinButton) { |
| return std::get<NativeTheme::InnerSpinButtonExtraParams>(extra_params) |
| .spin_up |
| ? SPNP_UP |
| : SPNP_DOWN; |
| } |
| if (part == NativeTheme::kTrackbarThumb) { |
| return std::get<NativeTheme::TrackbarExtraParams>(extra_params).vertical |
| ? TKP_THUMBVERT |
| : TKP_THUMBBOTTOM; |
| } |
| if (part == NativeTheme::kTrackbarTrack) { |
| return std::get<NativeTheme::TrackbarExtraParams>(extra_params).vertical |
| ? TKP_TRACKVERT |
| : TKP_TRACK; |
| } |
| |
| static constexpr auto kPartMap = |
| base::MakeFixedFlatMap<NativeTheme::Part, int>( |
| {{NativeTheme::kCheckbox, BP_CHECKBOX}, |
| {NativeTheme::kPushButton, BP_PUSHBUTTON}, |
| {NativeTheme::kRadio, BP_RADIOBUTTON}, |
| {NativeTheme::kMenuList, CP_DROPDOWNBUTTON}, |
| {NativeTheme::kTextField, EP_EDITTEXT}, |
| {NativeTheme::kMenuCheck, MENU_POPUPCHECK}, |
| {NativeTheme::kMenuCheckBackground, MENU_POPUPCHECKBACKGROUND}, |
| {NativeTheme::kMenuPopupGutter, MENU_POPUPGUTTER}, |
| {NativeTheme::kMenuPopupSeparator, MENU_POPUPSEPARATOR}, |
| {NativeTheme::kMenuPopupArrow, MENU_POPUPSUBMENU}, |
| {NativeTheme::kProgressBar, PP_BAR}, |
| {NativeTheme::kScrollbarDownArrow, SBP_ARROWBTN}, |
| {NativeTheme::kScrollbarLeftArrow, SBP_ARROWBTN}, |
| {NativeTheme::kScrollbarRightArrow, SBP_ARROWBTN}, |
| {NativeTheme::kScrollbarUpArrow, SBP_ARROWBTN}, |
| {NativeTheme::kScrollbarHorizontalGripper, SBP_GRIPPERHORZ}, |
| {NativeTheme::kScrollbarVerticalGripper, SBP_GRIPPERVERT}, |
| {NativeTheme::kScrollbarHorizontalThumb, SBP_THUMBBTNHORZ}, |
| {NativeTheme::kScrollbarVerticalThumb, SBP_THUMBBTNVERT}, |
| {NativeTheme::kWindowResizeGripper, |
| // Use the status bar gripper. There doesn't seem to be a standard |
| // gripper in Windows for the space between scrollbars. This is |
| // pretty close, but it's supposed to be painted over a status bar. |
| SP_GRIPPER}, |
| {NativeTheme::kTabPanelBackground, TABP_BODY}}); |
| return kPartMap.at(part); |
| } |
| |
| int GetWindowsState(NativeTheme::Part part, |
| NativeTheme::State state, |
| const NativeTheme::ExtraParams& extra_params) { |
| if (part == NativeTheme::kCheckbox) { |
| const auto& button = std::get<NativeTheme::ButtonExtraParams>(extra_params); |
| if (button.checked) { |
| return std::to_array({CBS_CHECKEDDISABLED, CBS_CHECKEDHOT, |
| CBS_CHECKEDNORMAL, CBS_CHECKEDPRESSED})[state]; |
| } |
| if (button.indeterminate) { |
| return std::to_array({CBS_MIXEDDISABLED, CBS_MIXEDHOT, CBS_MIXEDNORMAL, |
| CBS_MIXEDPRESSED})[state]; |
| } |
| return std::to_array({CBS_UNCHECKEDDISABLED, CBS_UNCHECKEDHOT, |
| CBS_UNCHECKEDNORMAL, CBS_UNCHECKEDPRESSED})[state]; |
| } |
| if (part == NativeTheme::kInnerSpinButton && |
| std::get<NativeTheme::InnerSpinButtonExtraParams>(extra_params).spin_up) { |
| return std::to_array( |
| {UPS_DISABLED, UPS_HOT, UPS_NORMAL, UPS_PRESSED})[state]; |
| } |
| if (part == NativeTheme::kMenuCheck && |
| std::get<NativeTheme::MenuCheckExtraParams>(extra_params).is_radio) { |
| return (state == NativeTheme::kDisabled) ? MC_BULLETDISABLED |
| : MC_BULLETNORMAL; |
| } |
| if (part == NativeTheme::kPushButton && state == NativeTheme::kNormal && |
| std::get<NativeTheme::ButtonExtraParams>(extra_params).is_default) { |
| return PBS_DEFAULTED; |
| } |
| if (part == NativeTheme::kRadio && |
| std::get<NativeTheme::ButtonExtraParams>(extra_params).checked) { |
| return std::to_array({RBS_CHECKEDDISABLED, RBS_CHECKEDHOT, |
| RBS_CHECKEDNORMAL, RBS_CHECKEDPRESSED})[state]; |
| } |
| if (part >= NativeTheme::kScrollbarDownArrow && |
| part <= NativeTheme::kScrollbarUpArrow && |
| state == NativeTheme::kHovered && |
| std::get<NativeTheme::ScrollbarArrowExtraParams>(extra_params) |
| .is_hovering) { |
| return std::to_array( |
| {ABS_DOWNHOVER, ABS_LEFTHOVER, ABS_RIGHTHOVER, |
| ABS_UPHOVER})[part - NativeTheme::kScrollbarDownArrow]; |
| } |
| if ((part == NativeTheme::kScrollbarHorizontalThumb || |
| part == NativeTheme::kScrollbarVerticalThumb || |
| part == NativeTheme::kScrollbarHorizontalGripper || |
| part == NativeTheme::kScrollbarVerticalGripper) && |
| state == NativeTheme::kHovered && |
| !std::get<NativeTheme::ScrollbarThumbExtraParams>(extra_params) |
| .is_hovering) { |
| return SCRBS_HOT; |
| } |
| if (part >= NativeTheme::kScrollbarHorizontalThumb && |
| part <= NativeTheme::kScrollbarVerticalGripper) { |
| return std::to_array( |
| {SCRBS_DISABLED, SCRBS_HOVER, SCRBS_NORMAL, SCRBS_PRESSED})[state]; |
| } |
| if (part == NativeTheme::kTextField && state == NativeTheme::kNormal) { |
| const auto& text_field = |
| std::get<NativeTheme::TextFieldExtraParams>(extra_params); |
| if (text_field.is_read_only) { |
| return ETS_READONLY; |
| } |
| if (text_field.is_focused) { |
| return ETS_FOCUSED; |
| } |
| } |
| if (part == NativeTheme::kTrackbarThumb || |
| part == NativeTheme::kTrackbarTrack) { |
| return std::to_array( |
| {TUS_DISABLED, TUS_HOT, TUS_NORMAL, TUS_PRESSED})[state]; |
| } |
| if (part == NativeTheme::kMenuPopupGutter || |
| part == NativeTheme::kMenuPopupSeparator || |
| part == NativeTheme::kProgressBar || |
| part == NativeTheme::kTabPanelBackground || |
| part == NativeTheme::kWindowResizeGripper) { |
| return 0; |
| } |
| |
| static constexpr auto kStateMap = base::MakeFixedFlatMap< |
| NativeTheme::Part, std::array<int, NativeTheme::kNumStates>>( |
| {{NativeTheme::kInnerSpinButton, |
| {DNS_DISABLED, DNS_HOT, DNS_NORMAL, DNS_PRESSED}}, |
| {NativeTheme::kMenuList, |
| {CBXS_DISABLED, CBXS_HOT, CBXS_NORMAL, CBXS_PRESSED}}, |
| {NativeTheme::kMenuCheck, |
| {MC_CHECKMARKDISABLED, MC_CHECKMARKNORMAL, MC_CHECKMARKNORMAL, |
| MC_CHECKMARKNORMAL}}, |
| {NativeTheme::kMenuCheckBackground, |
| {MCB_DISABLED, MCB_NORMAL, MCB_NORMAL, MCB_NORMAL}}, |
| {NativeTheme::kMenuPopupArrow, |
| {MSM_DISABLED, MSM_NORMAL, MSM_NORMAL, MSM_NORMAL}}, |
| {NativeTheme::kPushButton, |
| {PBS_DISABLED, PBS_HOT, PBS_NORMAL, PBS_PRESSED}}, |
| {NativeTheme::kRadio, |
| {RBS_UNCHECKEDDISABLED, RBS_UNCHECKEDHOT, RBS_UNCHECKEDNORMAL, |
| RBS_UNCHECKEDPRESSED}}, |
| {NativeTheme::kScrollbarDownArrow, |
| {ABS_DOWNDISABLED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNPRESSED}}, |
| {NativeTheme::kScrollbarLeftArrow, |
| {ABS_LEFTDISABLED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTPRESSED}}, |
| {NativeTheme::kScrollbarRightArrow, |
| {ABS_RIGHTDISABLED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTPRESSED}}, |
| {NativeTheme::kScrollbarUpArrow, |
| {ABS_UPDISABLED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPPRESSED}}, |
| {NativeTheme::kTextField, |
| {ETS_DISABLED, ETS_HOT, ETS_NORMAL, ETS_SELECTED}}}); |
| return kStateMap.at(part)[state]; |
| } |
| |
| void PaintMenuSeparator( |
| cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| const NativeTheme::MenuSeparatorExtraParams& extra_params) { |
| CHECK(color_provider); |
| const gfx::RectF rect(*extra_params.paint_rect); |
| gfx::PointF start = rect.CenterPoint(); |
| gfx::PointF end = start; |
| if (extra_params.type == VERTICAL_SEPARATOR) { |
| start.set_y(rect.y()); |
| end.set_y(rect.bottom()); |
| } else { |
| start.set_x(rect.x()); |
| end.set_x(rect.right()); |
| } |
| |
| cc::PaintFlags flags; |
| flags.setColor(color_provider->GetColor(extra_params.color_id)); |
| canvas->drawLine(start.x(), start.y(), end.x(), end.y(), flags); |
| } |
| |
| void PaintMenuGutter(cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| const gfx::Rect& rect) { |
| CHECK(color_provider); |
| cc::PaintFlags flags; |
| flags.setColor(color_provider->GetColor(kColorMenuSeparator)); |
| const int center_x = rect.x() + rect.width() / 2; |
| canvas->drawLine(center_x, rect.y(), center_x, rect.bottom(), flags); |
| } |
| |
| void PaintMenuBackground(cc::PaintCanvas* canvas, |
| const ColorProvider* color_provider, |
| const gfx::Rect& rect) { |
| CHECK(color_provider); |
| cc::PaintFlags flags; |
| flags.setColor(color_provider->GetColor(kColorMenuBackground)); |
| canvas->drawRect(gfx::RectToSkRect(rect), flags); |
| } |
| |
| void PaintButtonClassic(HDC hdc, |
| NativeTheme::Part part, |
| NativeTheme::State state, |
| RECT* rect, |
| const NativeTheme::ButtonExtraParams& extra_params) { |
| if ((part == NativeTheme::kPushButton) && |
| ((state == NativeTheme::kPressed) || extra_params.is_default)) { |
| // Pressed or defaulted buttons have a shadow replacing the outer 1 px. |
| if (HBRUSH brush = GetSysColorBrush(COLOR_3DDKSHADOW)) { |
| FrameRect(hdc, rect, brush); |
| InflateRect(rect, -1, -1); |
| } |
| } |
| |
| int classic_state = extra_params.classic_state; |
| if (part == NativeTheme::kCheckbox) { |
| classic_state |= DFCS_BUTTONCHECK; |
| } else if (part == NativeTheme::kPushButton) { |
| classic_state |= DFCS_BUTTONRADIO; |
| } else if (part == NativeTheme::kRadio) { |
| classic_state |= DFCS_BUTTONPUSH; |
| } |
| if (state == NativeTheme::kDisabled) { |
| classic_state |= DFCS_INACTIVE; |
| } else if (state == NativeTheme::kPressed) { |
| classic_state |= DFCS_PUSHED; |
| } |
| if (extra_params.checked) { |
| classic_state |= DFCS_CHECKED; |
| } |
| DrawFrameControl(hdc, rect, DFC_BUTTON, classic_state); |
| |
| // Draw a focus rectangle (the dotted line box) on defaulted buttons. |
| if ((part == NativeTheme::kPushButton) && extra_params.is_default) { |
| InflateRect(rect, -GetSystemMetrics(SM_CXEDGE), |
| -GetSystemMetrics(SM_CYEDGE)); |
| DrawFocusRect(hdc, rect); |
| } |
| |
| // Classic theme doesn't support indeterminate checkboxes. We draw a |
| // rectangle inside a checkbox like IE10 does. |
| if ((part == NativeTheme::kCheckbox) && extra_params.indeterminate) { |
| RECT inner_rect = *rect; |
| // "4 / 13" matches IE10 in classic theme. |
| const int padding = (inner_rect.right - inner_rect.left) * 4 / 13; |
| InflateRect(&inner_rect, -padding, -padding); |
| FillRect( |
| hdc, &inner_rect, |
| GetSysColorBrush((state == NativeTheme::kDisabled) ? COLOR_GRAYTEXT |
| : COLOR_WINDOWTEXT)); |
| } |
| } |
| |
| void PaintLeftMenuArrowThemed(HDC hdc, |
| HANDLE handle, |
| int part_id, |
| int state_id, |
| const gfx::Rect& rect) { |
| // There is no way to tell the uxtheme API to draw a left pointing arrow; it |
| // doesn't have a flag equivalent to `DFCS_MENUARROWRIGHT`. But they are |
| // needed for RTL locales on Vista. So use a memory DC and mirror the region |
| // with GDI's `StretchBlt()`. |
| base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc)); |
| base::win::ScopedGDIObject<HBITMAP> mem_bitmap( |
| CreateCompatibleBitmap(hdc, rect.width(), rect.height())); |
| base::win::ScopedSelectObject select_bitmap(mem_dc.Get(), mem_bitmap.get()); |
| // Copy and horizontally mirror the background from hdc into mem_dc. Use a |
| // negative-width source rect, starting at the rightmost pixel. |
| StretchBlt(mem_dc.Get(), 0, 0, rect.width(), rect.height(), hdc, |
| rect.right() - 1, rect.y(), -rect.width(), rect.height(), SRCCOPY); |
| // Draw the arrow. |
| RECT theme_rect = { |
| .left = 0, .top = 0, .right = rect.width(), .bottom = rect.height()}; |
| DrawThemeBackground(handle, mem_dc.Get(), part_id, state_id, &theme_rect, |
| nullptr); |
| // Copy and mirror the result back into mem_dc. |
| StretchBlt(hdc, rect.x(), rect.y(), rect.width(), rect.height(), mem_dc.Get(), |
| rect.width() - 1, 0, -rect.width(), rect.height(), SRCCOPY); |
| } |
| |
| void PaintScrollbarArrowClassic(HDC hdc, |
| NativeTheme::Part part, |
| NativeTheme::State state, |
| RECT* rect) { |
| static constexpr auto kParts = std::to_array( |
| {DFCS_SCROLLDOWN, DFCS_SCROLLLEFT, DFCS_SCROLLRIGHT, DFCS_SCROLLUP}); |
| static constexpr auto kStates = |
| std::to_array({DFCS_INACTIVE, DFCS_HOT, 0, DFCS_PUSHED}); |
| DrawFrameControl( |
| hdc, rect, DFC_SCROLL, |
| kParts[part - NativeTheme::kScrollbarDownArrow] | kStates[state]); |
| } |
| |
| void PaintScrollbarTrackClassic( |
| SkCanvas* canvas, |
| HDC hdc, |
| RECT* rect, |
| const NativeTheme::ScrollbarTrackExtraParams& extra_params) { |
| const auto& os_settings_provider = OsSettingsProvider::Get(); |
| using enum OsSettingsProvider::ColorId; |
| if (const auto scrollbar_color = os_settings_provider.Color(kScrollbar); |
| (scrollbar_color != os_settings_provider.Color(kButtonFace)) && |
| (scrollbar_color != os_settings_provider.Color(kWindow))) { |
| FillRect(hdc, rect, reinterpret_cast<HBRUSH>(COLOR_SCROLLBAR + 1)); |
| } else { |
| SkPaint paint; |
| SetCheckerboardShader(&paint, extra_params.track_x, extra_params.track_y); |
| canvas->drawIRect(skia::RECTToSkIRect(*rect), paint); |
| } |
| if (extra_params.classic_state & DFCS_PUSHED) { |
| InvertRect(hdc, rect); |
| } |
| } |
| |
| void PaintHorizontalTrackbarThumbClassic( |
| SkCanvas* canvas, |
| HDC hdc, |
| const RECT& rect, |
| const NativeTheme::TrackbarExtraParams& extra_params) { |
| // Split rect into top and bottom pieces. |
| const int half_thickness = (rect.right - rect.left) / 2; |
| RECT top_section = rect; |
| top_section.bottom -= half_thickness; |
| DrawEdge(hdc, &top_section, EDGE_RAISED, |
| BF_LEFT | BF_TOP | BF_RIGHT | BF_SOFT | BF_MIDDLE | BF_ADJUST); |
| |
| // Split bottom piece into two halves. |
| RECT left_half = rect; |
| left_half.top = top_section.bottom; |
| RECT right_half = left_half; |
| right_half.left += half_thickness; |
| left_half.right = right_half.left; |
| DrawEdge(hdc, &left_half, EDGE_RAISED, |
| BF_DIAGONAL_ENDTOPLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST); |
| DrawEdge(hdc, &right_half, EDGE_RAISED, |
| BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST); |
| |
| if (!(extra_params.classic_state & DFCS_PUSHED)) { |
| return; |
| } |
| |
| // Draw hatching. |
| SkPaint paint; |
| SetCheckerboardShader(&paint, rect.left, rect.top); |
| |
| // Fill all three pieces with the pattern. |
| canvas->drawIRect(skia::RECTToSkIRect(top_section), paint); |
| |
| const SkPath left_triangle = SkPath::Polygon( |
| { |
| SkPoint(left_half.left, left_half.top), |
| SkPoint(left_half.right, left_half.top), |
| SkPoint(left_half.right, left_half.bottom), |
| }, |
| /*isClosed=*/true); |
| canvas->drawPath(left_triangle, paint); |
| |
| const SkPath right_triangle = SkPath::Polygon( |
| { |
| SkPoint(right_half.left, right_half.top), |
| SkPoint(right_half.right, right_half.top), |
| SkPoint(right_half.left, right_half.bottom), |
| }, |
| /*isClosed=*/true); |
| canvas->drawPath(right_triangle, paint); |
| } |
| |
| void PaintProgressBarOverlayThemed( |
| HDC hdc, |
| HANDLE handle, |
| RECT* bar_rect, |
| RECT* value_rect, |
| const NativeTheme::ProgressBarExtraParams& extra_params) { |
| // There is no documentation about the animation of the indeterminate progress |
| // bar. The following are guesses based on observing other programs. |
| constexpr int kOverlayWidth = 120; |
| const int pixels_per_second = extra_params.determinate ? 300 : 175; |
| |
| int bar_width = bar_rect->right - bar_rect->left; |
| RECT overlay_rect; |
| if (extra_params.determinate) { |
| // We care about the direction here because PP_CHUNK painting is asymmetric. |
| // TODO(morrita): This RTL guess can be wrong. We should pass in the |
| // direction from WebKit. |
| const bool mirror = bar_rect->right == value_rect->right && |
| bar_rect->left != value_rect->left; |
| const DTBGOPTS value_draw_options = { |
| .dwSize = sizeof(DTBGOPTS), |
| .dwFlags = static_cast<DWORD>(mirror ? DTBG_MIRRORDC : 0), |
| .rcClip = *bar_rect}; |
| |
| // On Vista or later, the progress bar part has a single-block value part |
| // and a glossy effect. The value part has exactly same height as the bar |
| // part, so we don't need to shrink the rect. |
| DrawThemeBackgroundEx(handle, hdc, PP_FILL, 0, value_rect, |
| &value_draw_options); |
| |
| overlay_rect = *value_rect; |
| } else { |
| // The glossy overlay for the indeterminate progress bar has a small pause |
| // after each animation. Emulate this by adding an invisible margin the |
| // animation has to traverse. |
| bar_width += pixels_per_second; |
| overlay_rect = *bar_rect; |
| } |
| |
| const int animation_width = bar_width + kOverlayWidth; |
| const double interval = |
| static_cast<double>(animation_width) / pixels_per_second; |
| const double ratio = |
| std::fmod(extra_params.animated_seconds, interval) / interval; |
| overlay_rect.right = |
| overlay_rect.left + base::ClampFloor(animation_width * ratio); |
| overlay_rect.left = overlay_rect.right - kOverlayWidth; |
| DrawThemeBackground(handle, hdc, PP_MOVEOVERLAY, 0, &overlay_rect, |
| extra_params.determinate ? value_rect : bar_rect); |
| } |
| |
| void PaintTextFieldThemed( |
| HDC hdc, |
| HANDLE handle, |
| HBRUSH bg_brush, |
| int part_id, |
| int state_id, |
| RECT* rect, |
| const NativeTheme::TextFieldExtraParams& extra_params) { |
| static constexpr DTBGOPTS kOmitBorderOptions = {.dwSize = sizeof(DTBGOPTS), |
| .dwFlags = DTBG_OMITBORDER, |
| .rcClip = {0, 0, 0, 0}}; |
| DrawThemeBackgroundEx( |
| handle, hdc, part_id, state_id, rect, |
| extra_params.draw_edges ? nullptr : &kOmitBorderOptions); |
| |
| if (extra_params.fill_content_area) { |
| RECT content_rect; |
| GetThemeBackgroundContentRect(handle, hdc, part_id, state_id, rect, |
| &content_rect); |
| FillRect(hdc, &content_rect, bg_brush); |
| } |
| } |
| |
| void PaintTextFieldClassic( |
| HDC hdc, |
| HBRUSH bg_brush, |
| RECT* rect, |
| const NativeTheme::TextFieldExtraParams& extra_params) { |
| if (extra_params.draw_edges) { |
| DrawEdge(hdc, rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST); |
| } |
| |
| if (extra_params.fill_content_area) { |
| if (extra_params.classic_state & DFCS_INACTIVE) { |
| bg_brush = reinterpret_cast<HBRUSH>(COLOR_BTNFACE + 1); |
| } |
| FillRect(hdc, rect, bg_brush); |
| } |
| } |
| |
| void PaintScaledTheme(HANDLE theme, |
| HDC hdc, |
| int part_id, |
| int state_id, |
| const gfx::Rect& rect) { |
| // Correct the scaling and positioning of sub-components such as scrollbar |
| // arrows and thumb grippers in the event that the world transform applies |
| // scaling (e.g. in high-DPI mode). |
| if (XFORM save_transform; GetWorldTransform(hdc, &save_transform)) { |
| if (float scale = save_transform.eM11; |
| scale != 1 && save_transform.eM12 == 0) { |
| ModifyWorldTransform(hdc, NULL, MWT_IDENTITY); |
| gfx::Rect scaled_rect = gfx::ScaleToEnclosedRect(rect, scale); |
| scaled_rect.Offset(save_transform.eDx, save_transform.eDy); |
| RECT bounds = scaled_rect.ToRECT(); |
| DrawThemeBackground(theme, hdc, part_id, state_id, &bounds, nullptr); |
| SetWorldTransform(hdc, &save_transform); |
| return; |
| } |
| } |
| RECT bounds = rect.ToRECT(); |
| DrawThemeBackground(theme, hdc, part_id, state_id, &bounds, nullptr); |
| } |
| |
| void PaintFrameControl(HDC hdc, |
| const gfx::Rect& rect, |
| UINT type, |
| UINT state, |
| bool is_selected, |
| NativeTheme::State control_state) { |
| const int width = rect.width(); |
| const int height = rect.height(); |
| |
| // `DrawFrameControl()` for menu arrow/check wants a monochrome bitmap. |
| base::win::ScopedGDIObject<HBITMAP> mask_bitmap( |
| CreateBitmap(width, height, 1, 1, nullptr)); |
| if (!mask_bitmap.get()) { |
| return; |
| } |
| |
| base::win::ScopedCreateDC bitmap_dc(CreateCompatibleDC(nullptr)); |
| base::win::ScopedSelectObject select_bitmap(bitmap_dc.Get(), |
| mask_bitmap.get()); |
| RECT local_rect = {.left = 0, .top = 0, .right = width, .bottom = height}; |
| DrawFrameControl(bitmap_dc.Get(), &local_rect, type, state); |
| |
| // We're going to use `BitBlt()` with a black-and-white mask. This results in |
| // using the dest DC's text color for the black bits in the mask, and the dest |
| // DC's background color for the white bits in the mask. `DrawFrameControl()` |
| // draws the check in black, and the background in white. |
| int bg_color_key = COLOR_MENU; |
| int text_color_key = COLOR_MENUTEXT; |
| if (control_state == NativeTheme::kDisabled) { |
| bg_color_key = is_selected ? COLOR_HIGHLIGHT : COLOR_MENU; |
| text_color_key = COLOR_GRAYTEXT; |
| } else if (control_state == NativeTheme::kHovered) { |
| bg_color_key = COLOR_HIGHLIGHT; |
| text_color_key = COLOR_HIGHLIGHTTEXT; |
| } |
| const COLORREF old_bg_color = SetBkColor(hdc, GetSysColor(bg_color_key)); |
| const COLORREF old_text_color = |
| SetTextColor(hdc, GetSysColor(text_color_key)); |
| BitBlt(hdc, rect.x(), rect.y(), width, height, bitmap_dc.Get(), 0, 0, |
| SRCCOPY); |
| SetBkColor(hdc, old_bg_color); |
| SetTextColor(hdc, old_text_color); |
| } |
| |
| void PaintDirect(SkCanvas* destination_canvas, |
| HDC hdc, |
| NativeTheme::Part part, |
| NativeTheme::State state, |
| const gfx::Rect& rect, |
| const NativeTheme::ExtraParams& extra_params) { |
| if (part == NativeTheme::kScrollbarCorner) { |
| // Special-cased here since there is no theme name for kScrollbarCorner. |
| destination_canvas->drawColor(SK_ColorWHITE, SkBlendMode::kSrc); |
| return; |
| } |
| |
| RECT rect_win = rect.ToRECT(); |
| if (part == NativeTheme::kTrackbarTrack) { |
| // Make the channel be 4 px thick in the center of the supplied rect. (4 px |
| // matches what XP does in various menus; `GetThemePartSize()` doesn't seem |
| // to return good values here.) |
| constexpr int kChannelThickness = 4; |
| if (std::get<NativeTheme::TrackbarExtraParams>(extra_params).vertical) { |
| rect_win.top += (rect_win.bottom - rect_win.top - kChannelThickness) / 2; |
| rect_win.bottom = rect_win.top + kChannelThickness; |
| } else { |
| rect_win.left += (rect_win.right - rect_win.left - kChannelThickness) / 2; |
| rect_win.right = rect_win.left + kChannelThickness; |
| } |
| } |
| |
| // Most parts can be drawn simply when there is a theme handle. |
| const HANDLE handle = GetThemeHandle(part); |
| const int part_id = GetWindowsPart(part, extra_params); |
| const int state_id = GetWindowsState(part, state, extra_params); |
| if (handle) { |
| if (part == NativeTheme::kMenuPopupArrow && |
| !std::get<NativeTheme::MenuArrowExtraParams>(extra_params) |
| .pointing_right) { |
| // The right-pointing arrow can use the common code, but the left-pointing |
| // one needs custom code. |
| PaintLeftMenuArrowThemed(hdc, handle, part_id, state_id, rect); |
| return; |
| } |
| if (part >= NativeTheme::kScrollbarDownArrow && |
| part <= NativeTheme::kScrollbarVerticalThumb) { |
| PaintScaledTheme(handle, hdc, part_id, state_id, rect); |
| return; |
| } |
| if (part == NativeTheme::kCheckbox || |
| part == NativeTheme::kInnerSpinButton || |
| part == NativeTheme::kMenuList || part == NativeTheme::kMenuCheck || |
| part == NativeTheme::kMenuCheckBackground || |
| part == NativeTheme::kMenuPopupArrow || |
| part == NativeTheme::kProgressBar || part == NativeTheme::kPushButton || |
| part == NativeTheme::kRadio || |
| part == NativeTheme::kScrollbarHorizontalTrack || |
| part == NativeTheme::kScrollbarVerticalTrack || |
| part == NativeTheme::kTabPanelBackground || |
| part == NativeTheme::kTrackbarThumb || |
| part == NativeTheme::kTrackbarTrack || |
| part == NativeTheme::kWindowResizeGripper) { |
| DrawThemeBackground(handle, hdc, part_id, state_id, &rect_win, nullptr); |
| if (part != NativeTheme::kProgressBar) { |
| return; |
| } |
| } |
| } |
| |
| // Do any further painting the common code couldn't handle. |
| switch (part) { |
| case NativeTheme::kCheckbox: |
| case NativeTheme::kPushButton: |
| case NativeTheme::kRadio: |
| PaintButtonClassic( |
| hdc, part, state, &rect_win, |
| std::get<NativeTheme::ButtonExtraParams>(extra_params)); |
| return; |
| case NativeTheme::kInnerSpinButton: |
| DrawFrameControl( |
| hdc, &rect_win, DFC_SCROLL, |
| std::get<NativeTheme::InnerSpinButtonExtraParams>(extra_params) |
| .classic_state); |
| return; |
| case NativeTheme::kMenuCheck: { |
| const auto& menu_check = |
| std::get<NativeTheme::MenuCheckExtraParams>(extra_params); |
| PaintFrameControl(hdc, rect, DFC_MENU, |
| menu_check.is_radio ? DFCS_MENUBULLET : DFCS_MENUCHECK, |
| menu_check.is_selected, state); |
| return; |
| } |
| case NativeTheme::kMenuList: |
| DrawFrameControl( |
| hdc, &rect_win, DFC_SCROLL, |
| DFCS_SCROLLCOMBOBOX | |
| std::get<NativeTheme::MenuListExtraParams>(extra_params) |
| .classic_state); |
| return; |
| case NativeTheme::kMenuPopupArrow: { |
| const auto& menu_arrow = |
| std::get<NativeTheme::MenuArrowExtraParams>(extra_params); |
| // For some reason, Windows uses the name DFCS_MENUARROWRIGHT to indicate |
| // a left pointing arrow. |
| PaintFrameControl( |
| hdc, rect, DFC_MENU, |
| menu_arrow.pointing_right ? DFCS_MENUARROW : DFCS_MENUARROWRIGHT, |
| menu_arrow.is_selected, state); |
| return; |
| } |
| case NativeTheme::kProgressBar: { |
| const auto& progress_bar = |
| std::get<NativeTheme::ProgressBarExtraParams>(extra_params); |
| RECT value_rect = |
| gfx::Rect(progress_bar.value_rect_x, progress_bar.value_rect_y, |
| progress_bar.value_rect_width, |
| progress_bar.value_rect_height) |
| .ToRECT(); |
| if (handle) { |
| PaintProgressBarOverlayThemed(hdc, handle, &rect_win, &value_rect, |
| progress_bar); |
| } else { |
| FillRect(hdc, &rect_win, GetSysColorBrush(COLOR_BTNFACE)); |
| FillRect(hdc, &value_rect, GetSysColorBrush(COLOR_BTNSHADOW)); |
| DrawEdge(hdc, &rect_win, EDGE_SUNKEN, BF_RECT | BF_ADJUST); |
| } |
| return; |
| } |
| case NativeTheme::kScrollbarDownArrow: |
| case NativeTheme::kScrollbarLeftArrow: |
| case NativeTheme::kScrollbarRightArrow: |
| case NativeTheme::kScrollbarUpArrow: |
| PaintScrollbarArrowClassic(hdc, part, state, &rect_win); |
| return; |
| case NativeTheme::kScrollbarHorizontalThumb: |
| case NativeTheme::kScrollbarVerticalThumb: |
| DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_MIDDLE); |
| return; |
| case NativeTheme::kScrollbarHorizontalTrack: |
| case NativeTheme::kScrollbarVerticalTrack: |
| PaintScrollbarTrackClassic( |
| destination_canvas, hdc, &rect_win, |
| std::get<NativeTheme::ScrollbarTrackExtraParams>(extra_params)); |
| return; |
| case NativeTheme::kTabPanelBackground: |
| // Classic just renders a flat color background. |
| FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_3DFACE + 1)); |
| return; |
| case NativeTheme::kTextField: { |
| // TODO(mpcomplete): can we detect if the color is specified by the user, |
| // and if not, just use the system color? |
| // CreateSolidBrush() accepts a RGB value but alpha must be 0. |
| const auto& text_field = |
| std::get<NativeTheme::TextFieldExtraParams>(extra_params); |
| base::win::ScopedGDIObject<HBRUSH> bg_brush(CreateSolidBrush( |
| skia::SkColorToCOLORREF(text_field.background_color))); |
| if (handle) { |
| PaintTextFieldThemed(hdc, handle, bg_brush.get(), part_id, state_id, |
| &rect_win, text_field); |
| } else { |
| PaintTextFieldClassic(hdc, bg_brush.get(), &rect_win, text_field); |
| } |
| return; |
| } |
| case NativeTheme::kTrackbarThumb: { |
| const auto& trackbar = |
| std::get<NativeTheme::TrackbarExtraParams>(extra_params); |
| if (trackbar.vertical) { |
| DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_SOFT | BF_MIDDLE); |
| } else { |
| PaintHorizontalTrackbarThumbClassic(destination_canvas, hdc, rect_win, |
| trackbar); |
| } |
| return; |
| } |
| case NativeTheme::kTrackbarTrack: |
| DrawEdge(hdc, &rect_win, EDGE_SUNKEN, BF_RECT); |
| return; |
| case NativeTheme::kWindowResizeGripper: |
| // Draw a windows classic scrollbar gripper. |
| DrawFrameControl(hdc, &rect_win, DFC_SCROLL, DFCS_SCROLLSIZEGRIP); |
| return; |
| default: |
| return; |
| } |
| } |
| |
| void PaintIndirect(cc::PaintCanvas* destination_canvas, |
| NativeTheme::Part part, |
| NativeTheme::State state, |
| const gfx::Rect& rect, |
| NativeTheme::ExtraParams extra_params) { |
| // TODO(asvitkine): This path is pretty inefficient - for each paint operation |
| // it creates a new offscreen bitmap Skia canvas. This can be sped up by doing |
| // it only once per part/state and keeping a cache of the resulting bitmaps. |
| // |
| // TODO(enne): This could also potentially be sped up for software raster |
| // by moving these draw ops into `PaintRecord` itself and then moving the |
| // `PaintDirect()` code to be part of the raster for `PaintRecord`. |
| |
| // If this process doesn't have access to GDI, we'd need to use a shared |
| // memory segment instead, but that is not supported right now. |
| if (!base::win::IsUser32AndGdi32Available()) { |
| return; |
| } |
| |
| ScopedCreateDCWithBitmap offscreen_hdc(CreateCompatibleDC(nullptr)); |
| if (!offscreen_hdc.IsValid()) { |
| return; |
| } |
| |
| skia::InitializeDC(offscreen_hdc.Get()); |
| if (const HRGN clip = CreateRectRgn(0, 0, rect.width(), rect.height()); |
| (SelectClipRgn(offscreen_hdc.Get(), clip) == ERROR) || |
| !DeleteObject(clip)) { |
| return; |
| } |
| |
| base::win::ScopedGDIObject<HBITMAP> hbitmap = skia::CreateHBitmapXRGB8888( |
| rect.width(), rect.height(), nullptr, nullptr); |
| if (!offscreen_hdc.SelectBitmap(hbitmap.release())) { |
| return; |
| } |
| |
| // Will be null if lower-level Windows calls fail, or if the backing allocated |
| // is 0 pixels in size (which should never happen according to Windows |
| // documentation). |
| const sk_sp<SkSurface> offscreen_surface = |
| skia::MapPlatformSurface(offscreen_hdc.Get()); |
| if (!offscreen_surface) { |
| return; |
| } |
| |
| SkCanvas* const offscreen_canvas = offscreen_surface->getCanvas(); |
| CHECK(offscreen_canvas); |
| |
| // Some of the Windows theme drawing operations do not write correct alpha |
| // values for fully-opaque pixels; instead the pixels get alpha 0. This is |
| // especially a problem on Windows XP or when using the Classic theme. |
| // |
| // To work-around this, mark all pixels with a placeholder value, to detect |
| // which pixels get touched by the paint operation. After paint, set any |
| // pixels that have alpha 0 to opaque and placeholders to fully-transparent. |
| constexpr SkColor kPlaceholder = SkColorSetARGB(1, 0, 0, 0); |
| offscreen_canvas->clear(kPlaceholder); |
| |
| // Offset destination rects to have origin (0,0). |
| gfx::Rect adjusted_rect(rect.size()); |
| if (part == NativeTheme::kProgressBar) { |
| auto& progress_bar = |
| std::get<NativeTheme::ProgressBarExtraParams>(extra_params); |
| progress_bar.value_rect_x = 0; |
| progress_bar.value_rect_y = 0; |
| } else if (part == NativeTheme::kScrollbarHorizontalTrack || |
| part == NativeTheme::kScrollbarVerticalTrack) { |
| auto& scrollbar_track = |
| std::get<NativeTheme::ScrollbarTrackExtraParams>(extra_params); |
| scrollbar_track.track_x = 0; |
| scrollbar_track.track_y = 0; |
| } |
| // Draw the theme controls using existing HDC-drawing code. |
| PaintDirect(offscreen_canvas, offscreen_hdc.Get(), part, state, adjusted_rect, |
| extra_params); |
| |
| SkBitmap offscreen_bitmap = skia::MapPlatformBitmap(offscreen_hdc.Get()); |
| |
| // Post-process the pixels to fix up the alpha values (see big comment above). |
| const SkPMColor placeholder_value = SkPreMultiplyColor(kPlaceholder); |
| for (SkPMColor& pixel : |
| // SAFETY: `offscreen_bitmap` is the same size as `offscreen_hdc`, which |
| // is holding `hbitmap`, which is `rect.width()` x `rect.height()` pixels |
| // in size. |
| UNSAFE_BUFFERS(base::span(offscreen_bitmap.getAddr32(0, 0), |
| base::CheckMul(rect.width(), rect.height()) |
| .Cast<size_t>() |
| .ValueOrDie()))) { |
| if (pixel == placeholder_value) { |
| // Pixel wasn't touched - make it fully transparent. |
| pixel = SkPMColorSetARGB(0, 0, 0, 0); |
| } else if (SkPMColorGetA(pixel) == 0) { |
| // Pixel was touched but has incorrect alpha of 0, make it fully opaque. |
| pixel = SkPMColorSetARGB(0xFF, SkPMColorGetR(pixel), SkPMColorGetG(pixel), |
| SkPMColorGetB(pixel)); |
| } |
| } |
| |
| destination_canvas->drawImage( |
| cc::PaintImage::CreateFromBitmap(std::move(offscreen_bitmap)), rect.x(), |
| rect.y()); |
| } |
| |
| } // namespace |
| |
| // static |
| void NativeThemeWin::CloseHandles() { |
| for (auto& entry : *GetThemeHandles()) { |
| if (entry.second) { |
| CloseThemeData(entry.second); |
| entry.second = nullptr; |
| } |
| } |
| } |
| |
| gfx::Size NativeThemeWin::GetPartSize(Part part, |
| State state, |
| const ExtraParams& extra_params) const { |
| // The `GetThemePartSize()` call below returns the default size without |
| // accounting for user customization. |
| if (part >= kScrollbarDownArrow && part <= kScrollbarVerticalTrack) { |
| int size = |
| display::win::GetScreenWin()->GetSystemMetricsInDIP(SM_CXVSCROLL); |
| if (size == 0) { |
| size = 17; |
| } |
| return gfx::Size(size, size); |
| } |
| |
| if (HANDLE handle = GetThemeHandle(part)) { |
| base::win::ScopedGetDC screen_dc(nullptr); |
| SIZE size; |
| if (SUCCEEDED(GetThemePartSize(handle, screen_dc, |
| GetWindowsPart(part, extra_params), |
| GetWindowsState(part, state, extra_params), |
| nullptr, TS_TRUE, &size))) { |
| return gfx::Size(size.cx, size.cy); |
| } |
| } |
| |
| // TODO(rogerta): For now, we need to support radio buttons and checkboxes |
| // when theming is not enabled. Support for other parts can be added |
| // if/when needed. |
| return (part == kCheckbox || part == kRadio) ? gfx::Size(13, 13) |
| : gfx::Size(); |
| } |
| |
| NativeThemeWin::NativeThemeWin() = default; |
| |
| NativeThemeWin::~NativeThemeWin() { |
| CloseHandles(); |
| } |
| |
| void NativeThemeWin::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 { |
| switch (part) { |
| case kMenuPopupGutter: |
| PaintMenuGutter(canvas, color_provider, rect); |
| return; |
| case kMenuPopupSeparator: |
| PaintMenuSeparator(canvas, color_provider, |
| std::get<MenuSeparatorExtraParams>(extra_params)); |
| return; |
| case kMenuPopupBackground: |
| PaintMenuBackground(canvas, color_provider, rect); |
| return; |
| case kMenuItemBackground: |
| PaintMenuItemBackground(canvas, color_provider, state, rect, |
| std::get<MenuItemExtraParams>(extra_params)); |
| return; |
| default: |
| PaintIndirect(canvas, part, state, rect, extra_params); |
| return; |
| } |
| } |
| |
| void NativeThemeWin::OnToolkitSettingsChanged(bool force_notify) { |
| CloseHandles(); |
| NativeTheme::OnToolkitSettingsChanged(force_notify); |
| } |
| |
| } // namespace ui |
