1 /* -*- Mode: C++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
8 #include "ThemeCocoa.h"
10 #include "ThemeDrawing.h"
12 #include "mozilla/MathAlgorithms.h"
13 #include "mozilla/ClearOnShutdown.h"
14 #include "mozilla/dom/Document.h"
15 #include "mozilla/dom/HTMLMeterElement.h"
16 #include "mozilla/dom/HTMLProgressElement.h"
17 #include "mozilla/gfx/Rect.h"
18 #include "mozilla/gfx/Types.h"
19 #include "mozilla/gfx/Filters.h"
20 #include "mozilla/RelativeLuminanceUtils.h"
21 #include "mozilla/StaticPrefs_widget.h"
22 #include "mozilla/webrender/WebRenderAPI.h"
23 #include "nsCSSColorUtils.h"
24 #include "nsCSSRendering.h"
25 #include "nsScrollbarFrame.h"
26 #include "nsIScrollableFrame.h"
27 #include "nsIScrollbarMediator.h"
28 #include "nsDeviceContext.h"
29 #include "nsLayoutUtils.h"
30 #include "nsRangeFrame.h"
31 #include "PathHelpers.h"
32 #include "ScrollbarDrawingAndroid.h"
33 #include "ScrollbarDrawingCocoa.h"
34 #include "ScrollbarDrawingGTK.h"
35 #include "ScrollbarDrawingWin.h"
36 #include "ScrollbarDrawingWin11.h"
39 # include "mozilla/WindowsVersion.h"
42 using namespace mozilla
;
43 using namespace mozilla::dom
;
44 using namespace mozilla::gfx
;
45 using namespace mozilla::widget
;
49 static constexpr gfx::sRGBColor
sColorGrey10(
50 gfx::sRGBColor::UnusualFromARGB(0xffe9e9ed));
51 static constexpr gfx::sRGBColor
sColorGrey10Alpha50(
52 gfx::sRGBColor::UnusualFromARGB(0x7fe9e9ed));
53 static constexpr gfx::sRGBColor
sColorGrey20(
54 gfx::sRGBColor::UnusualFromARGB(0xffd0d0d7));
55 static constexpr gfx::sRGBColor
sColorGrey30(
56 gfx::sRGBColor::UnusualFromARGB(0xffb1b1b9));
57 static constexpr gfx::sRGBColor
sColorGrey40(
58 gfx::sRGBColor::UnusualFromARGB(0xff8f8f9d));
59 static constexpr gfx::sRGBColor
sColorGrey40Alpha50(
60 gfx::sRGBColor::UnusualFromARGB(0x7f8f8f9d));
61 static constexpr gfx::sRGBColor
sColorGrey50(
62 gfx::sRGBColor::UnusualFromARGB(0xff676774));
63 static constexpr gfx::sRGBColor
sColorGrey60(
64 gfx::sRGBColor::UnusualFromARGB(0xff484851));
66 static constexpr gfx::sRGBColor
sColorMeterGreen10(
67 gfx::sRGBColor::UnusualFromARGB(0xff00ab60));
68 static constexpr gfx::sRGBColor
sColorMeterGreen20(
69 gfx::sRGBColor::UnusualFromARGB(0xff056139));
70 static constexpr gfx::sRGBColor
sColorMeterYellow10(
71 gfx::sRGBColor::UnusualFromARGB(0xffffbd4f));
72 static constexpr gfx::sRGBColor
sColorMeterYellow20(
73 gfx::sRGBColor::UnusualFromARGB(0xffd2811e));
74 static constexpr gfx::sRGBColor
sColorMeterRed10(
75 gfx::sRGBColor::UnusualFromARGB(0xffe22850));
76 static constexpr gfx::sRGBColor
sColorMeterRed20(
77 gfx::sRGBColor::UnusualFromARGB(0xff810220));
79 static const CSSCoord kMinimumRangeThumbSize
= 20.0f
;
80 static const CSSCoord kMinimumDropdownArrowButtonWidth
= 18.0f
;
81 static const CSSCoord kMinimumSpinnerButtonWidth
= 18.0f
;
82 static const CSSCoord kMinimumSpinnerButtonHeight
= 9.0f
;
83 static const CSSCoord kButtonBorderWidth
= 1.0f
;
84 static const CSSCoord kMenulistBorderWidth
= 1.0f
;
85 static const CSSCoord kTextFieldBorderWidth
= 1.0f
;
86 static const CSSCoord kRangeHeight
= 6.0f
;
87 static const CSSCoord kProgressbarHeight
= 6.0f
;
88 static const CSSCoord kMeterHeight
= 12.0f
;
90 // nsCheckboxRadioFrame takes the bottom of the content box as the baseline.
91 // This border-width makes its baseline 2px under the bottom, which is nice.
92 static constexpr CSSCoord kCheckboxRadioBorderWidth
= 2.0f
;
94 static constexpr sRGBColor sTransparent
= sRGBColor::White(0.0);
96 // This pushes and pops a clip rect to the draw target.
98 // This is done to reduce fuzz in places where we may have antialiasing,
99 // because skia is not clip-invariant: given different clips, it does not
100 // guarantee the same result, even if the painted content doesn't intersect
103 // This is a bit sad, overall, but...
104 struct MOZ_RAII AutoClipRect
{
105 AutoClipRect(DrawTarget
& aDt
, const LayoutDeviceRect
& aRect
) : mDt(aDt
) {
106 mDt
.PushClipRect(aRect
.ToUnknownRect());
109 ~AutoClipRect() { mDt
.PopClip(); }
115 static StaticRefPtr
<Theme
> gNativeInstance
;
116 static StaticRefPtr
<Theme
> gNonNativeInstance
;
117 static StaticRefPtr
<Theme
> gRDMInstance
;
122 already_AddRefed
<Theme
> do_CreateNativeThemeDoNotUseDirectly() {
123 // Android doesn't have a native theme.
124 return do_AddRef(new Theme(Theme::ScrollbarStyle()));
128 already_AddRefed
<nsITheme
> do_GetBasicNativeThemeDoNotUseDirectly() {
129 if (MOZ_UNLIKELY(!gNonNativeInstance
)) {
130 UniquePtr
<ScrollbarDrawing
> scrollbarDrawing
= Theme::ScrollbarStyle();
131 #ifdef MOZ_WIDGET_COCOA
132 gNonNativeInstance
= new ThemeCocoa(std::move(scrollbarDrawing
));
134 gNonNativeInstance
= new Theme(std::move(scrollbarDrawing
));
136 ClearOnShutdown(&gNonNativeInstance
);
138 return do_AddRef(gNonNativeInstance
);
141 already_AddRefed
<nsITheme
> do_GetNativeThemeDoNotUseDirectly() {
142 if (MOZ_UNLIKELY(!gNativeInstance
)) {
143 gNativeInstance
= do_CreateNativeThemeDoNotUseDirectly();
144 ClearOnShutdown(&gNativeInstance
);
146 return do_AddRef(gNativeInstance
);
149 already_AddRefed
<nsITheme
> do_GetRDMThemeDoNotUseDirectly() {
150 if (MOZ_UNLIKELY(!gRDMInstance
)) {
151 gRDMInstance
= new Theme(MakeUnique
<ScrollbarDrawingAndroid
>());
152 ClearOnShutdown(&gRDMInstance
);
154 return do_AddRef(gRDMInstance
);
157 namespace mozilla::widget
{
159 NS_IMPL_ISUPPORTS_INHERITED(Theme
, nsNativeTheme
, nsITheme
)
161 static constexpr nsLiteralCString kPrefs
[] = {
162 "widget.non-native-theme.use-theme-accent"_ns
,
163 "widget.non-native-theme.win.scrollbar.use-system-size"_ns
,
164 "widget.non-native-theme.scrollbar.size.override"_ns
,
165 "widget.non-native-theme.scrollbar.style"_ns
,
169 for (const auto& pref
: kPrefs
) {
170 Preferences::RegisterCallback(PrefChangedCallback
, pref
);
172 LookAndFeelChanged();
175 void Theme::Shutdown() {
176 for (const auto& pref
: kPrefs
) {
177 Preferences::UnregisterCallback(PrefChangedCallback
, pref
);
182 void Theme::LookAndFeelChanged() {
183 ThemeColors::RecomputeAccentColors();
184 if (gNonNativeInstance
) {
185 gNonNativeInstance
->SetScrollbarDrawing(ScrollbarStyle());
187 if (gNativeInstance
) {
188 gNativeInstance
->SetScrollbarDrawing(ScrollbarStyle());
192 auto Theme::GetDPIRatio(nsPresContext
* aPc
, StyleAppearance aAppearance
)
194 // Widgets react to zoom, except scrollbars.
195 if (IsWidgetScrollbarPart(aAppearance
)) {
196 return GetScrollbarDrawing().GetDPIRatioForScrollbarPart(aPc
);
198 return DPIRatio(float(AppUnitsPerCSSPixel()) / aPc
->AppUnitsPerDevPixel());
201 auto Theme::GetDPIRatio(nsIFrame
* aFrame
, StyleAppearance aAppearance
)
203 return GetDPIRatio(aFrame
->PresContext(), aAppearance
);
206 // Checkbox and radio need to preserve aspect-ratio for compat. We also snap the
207 // size to exact device pixels to avoid snapping disorting the circles.
208 static LayoutDeviceRect
CheckBoxRadioRect(const LayoutDeviceRect
& aRect
) {
209 // Place a square rect in the center of aRect.
210 auto size
= std::trunc(std::min(aRect
.width
, aRect
.height
));
211 auto position
= aRect
.Center() - LayoutDevicePoint(size
* 0.5, size
* 0.5);
212 return LayoutDeviceRect(position
, LayoutDeviceSize(size
, size
));
215 std::tuple
<sRGBColor
, sRGBColor
, sRGBColor
> Theme::ComputeCheckboxColors(
216 const ElementState
& aState
, StyleAppearance aAppearance
,
217 const Colors
& aColors
) {
218 MOZ_ASSERT(aAppearance
== StyleAppearance::Checkbox
||
219 aAppearance
== StyleAppearance::Radio
);
221 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
222 bool isChecked
= aState
.HasState(ElementState::CHECKED
);
223 bool isIndeterminate
= aAppearance
== StyleAppearance::Checkbox
&&
224 aState
.HasState(ElementState::INDETERMINATE
);
226 if (isChecked
|| isIndeterminate
) {
228 auto bg
= ComputeBorderColor(aState
, aColors
, OutlineCoversBorder::No
);
229 auto fg
= aColors
.HighContrast()
230 ? aColors
.System(StyleSystemColor::Graytext
)
231 : sRGBColor::White(.8f
);
232 return std::make_tuple(bg
, bg
, fg
);
235 if (aColors
.HighContrast()) {
236 auto bg
= aColors
.System(StyleSystemColor::Selecteditem
);
237 auto fg
= aColors
.System(StyleSystemColor::Selecteditemtext
);
238 return std::make_tuple(bg
, bg
, fg
);
242 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
243 bool isHovered
= aState
.HasState(ElementState::HOVER
);
244 const auto& bg
= isActive
? aColors
.Accent().GetDarker()
245 : isHovered
? aColors
.Accent().GetDark()
246 : aColors
.Accent().Get();
247 const auto& fg
= aColors
.Accent().GetForeground();
248 return std::make_tuple(bg
, bg
, fg
);
252 ComputeTextfieldColors(aState
, aColors
, OutlineCoversBorder::No
);
253 // We don't paint a checkmark in this case so any color would do.
254 return std::make_tuple(bg
, border
, sTransparent
);
257 sRGBColor
Theme::ComputeBorderColor(const ElementState
& aState
,
258 const Colors
& aColors
,
259 OutlineCoversBorder aOutlineCoversBorder
) {
260 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
261 if (aColors
.HighContrast()) {
262 return aColors
.System(isDisabled
? StyleSystemColor::Graytext
263 : StyleSystemColor::Buttontext
);
266 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
267 bool isHovered
= aState
.HasState(ElementState::HOVER
);
268 bool isFocused
= aState
.HasState(ElementState::FOCUSRING
);
270 return sColorGrey40Alpha50
;
272 if (isFocused
&& aOutlineCoversBorder
== OutlineCoversBorder::Yes
) {
273 // If we draw the outline over the border, prevent issues where the border
274 // shows underneath if it snaps in the wrong direction by using a
275 // transparent border. An alternative to this is ensuring that we snap the
276 // offset in PaintRoundedFocusRect the same was a we snap border widths, so
277 // that negative offsets are guaranteed to cover the border.
278 // But this looks harder to mess up.
281 bool dark
= aColors
.IsDark();
283 return dark
? sColorGrey20
: sColorGrey60
;
286 return dark
? sColorGrey30
: sColorGrey50
;
291 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeButtonColors(
292 const ElementState
& aState
, const Colors
& aColors
, nsIFrame
* aFrame
) {
294 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
295 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
296 bool isHovered
= aState
.HasState(ElementState::HOVER
);
298 nscolor backgroundColor
= [&] {
300 return aColors
.SystemNs(StyleSystemColor::MozButtondisabledface
);
303 return aColors
.SystemNs(StyleSystemColor::MozButtonactiveface
);
306 return aColors
.SystemNs(StyleSystemColor::MozButtonhoverface
);
308 return aColors
.SystemNs(StyleSystemColor::Buttonface
);
311 if (aState
.HasState(ElementState::AUTOFILL
)) {
312 backgroundColor
= NS_ComposeColors(
314 aColors
.SystemNs(StyleSystemColor::MozAutofillBackground
));
317 const sRGBColor borderColor
=
318 ComputeBorderColor(aState
, aColors
, OutlineCoversBorder::Yes
);
319 return std::make_pair(sRGBColor::FromABGR(backgroundColor
), borderColor
);
322 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeTextfieldColors(
323 const ElementState
& aState
, const Colors
& aColors
,
324 OutlineCoversBorder aOutlineCoversBorder
) {
325 nscolor backgroundColor
= [&] {
326 if (aState
.HasState(ElementState::DISABLED
)) {
327 return aColors
.SystemNs(StyleSystemColor::MozDisabledfield
);
329 return aColors
.SystemNs(StyleSystemColor::Field
);
332 if (aState
.HasState(ElementState::AUTOFILL
)) {
333 backgroundColor
= NS_ComposeColors(
335 aColors
.SystemNs(StyleSystemColor::MozAutofillBackground
));
338 const sRGBColor borderColor
=
339 ComputeBorderColor(aState
, aColors
, aOutlineCoversBorder
);
340 return std::make_pair(sRGBColor::FromABGR(backgroundColor
), borderColor
);
343 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeRangeProgressColors(
344 const ElementState
& aState
, const Colors
& aColors
) {
345 if (aColors
.HighContrast()) {
346 return aColors
.SystemPair(StyleSystemColor::Selecteditem
,
347 StyleSystemColor::Buttontext
);
351 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
352 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
353 bool isHovered
= aState
.HasState(ElementState::HOVER
);
356 return std::make_pair(sColorGrey40Alpha50
, sColorGrey40Alpha50
);
358 if (isActive
|| isHovered
) {
359 return std::make_pair(aColors
.Accent().GetDark(),
360 aColors
.Accent().GetDarker());
362 return std::make_pair(aColors
.Accent().Get(), aColors
.Accent().GetDark());
365 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeRangeTrackColors(
366 const ElementState
& aState
, const Colors
& aColors
) {
367 if (aColors
.HighContrast()) {
368 return aColors
.SystemPair(StyleSystemColor::Window
,
369 StyleSystemColor::Buttontext
);
372 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
373 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
374 bool isHovered
= aState
.HasState(ElementState::HOVER
);
377 return std::make_pair(sColorGrey10Alpha50
, sColorGrey40Alpha50
);
379 if (isActive
|| isHovered
) {
380 return std::make_pair(sColorGrey20
, sColorGrey50
);
382 return std::make_pair(sColorGrey10
, sColorGrey40
);
385 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeRangeThumbColors(
386 const ElementState
& aState
, const Colors
& aColors
) {
387 if (aColors
.HighContrast()) {
388 return aColors
.SystemPair(StyleSystemColor::Selecteditemtext
,
389 StyleSystemColor::Selecteditem
);
393 aState
.HasAllStates(ElementState::HOVER
| ElementState::ACTIVE
);
394 bool isDisabled
= aState
.HasState(ElementState::DISABLED
);
395 bool isHovered
= aState
.HasState(ElementState::HOVER
);
397 const sRGBColor
& backgroundColor
= [&] {
402 return aColors
.Accent().Get();
410 const sRGBColor borderColor
= sRGBColor::OpaqueWhite();
411 return std::make_pair(backgroundColor
, borderColor
);
414 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeProgressColors(
415 const Colors
& aColors
) {
416 if (aColors
.HighContrast()) {
417 return aColors
.SystemPair(StyleSystemColor::Selecteditem
,
418 StyleSystemColor::Buttontext
);
420 return std::make_pair(aColors
.Accent().Get(), aColors
.Accent().GetDark());
423 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeProgressTrackColors(
424 const Colors
& aColors
) {
425 if (aColors
.HighContrast()) {
426 return aColors
.SystemPair(StyleSystemColor::Buttonface
,
427 StyleSystemColor::Buttontext
);
429 return std::make_pair(sColorGrey10
, sColorGrey40
);
432 std::pair
<sRGBColor
, sRGBColor
> Theme::ComputeMeterchunkColors(
433 const ElementState
& aMeterState
, const Colors
& aColors
) {
434 if (aColors
.HighContrast()) {
435 return ComputeProgressColors(aColors
);
437 sRGBColor borderColor
= sColorMeterGreen20
;
438 sRGBColor chunkColor
= sColorMeterGreen10
;
440 if (aMeterState
.HasState(ElementState::SUB_OPTIMUM
)) {
441 borderColor
= sColorMeterYellow20
;
442 chunkColor
= sColorMeterYellow10
;
443 } else if (aMeterState
.HasState(ElementState::SUB_SUB_OPTIMUM
)) {
444 borderColor
= sColorMeterRed20
;
445 chunkColor
= sColorMeterRed10
;
448 return std::make_pair(chunkColor
, borderColor
);
451 std::array
<sRGBColor
, 3> Theme::ComputeFocusRectColors(const Colors
& aColors
) {
452 if (aColors
.HighContrast()) {
453 return {aColors
.System(StyleSystemColor::Selecteditem
),
454 aColors
.System(StyleSystemColor::Buttontext
),
455 aColors
.System(StyleSystemColor::Window
)};
457 const auto& accent
= aColors
.Accent();
458 const sRGBColor middle
=
459 aColors
.IsDark() ? sRGBColor::Black(.3f
) : sRGBColor::White(.3f
);
460 return {accent
.Get(), middle
, accent
.GetLight()};
463 template <typename PaintBackendData
>
464 void Theme::PaintRoundedFocusRect(PaintBackendData
& aBackendData
,
465 const LayoutDeviceRect
& aRect
,
466 const Colors
& aColors
, DPIRatio aDpiRatio
,
467 CSSCoord aRadius
, CSSCoord aOffset
) {
468 // NOTE(emilio): If the widths or offsets here change, make sure to tweak
469 // the GetWidgetOverflow path for FocusOutline.
470 auto [innerColor
, middleColor
, outerColor
] = ComputeFocusRectColors(aColors
);
472 LayoutDeviceRect
focusRect(aRect
);
474 // The focus rect is painted outside of the border area (aRect), see:
476 // data:text/html,<div style="border: 1px solid; outline: 2px solid
479 // But some controls might provide a negative offset to cover the border, if
481 CSSCoord strokeWidth
= 2.0f
;
482 auto strokeWidthDevPx
=
483 LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth
, aDpiRatio
));
484 CSSCoord strokeRadius
= aRadius
;
485 focusRect
.Inflate(aOffset
* aDpiRatio
+ strokeWidthDevPx
);
487 ThemeDrawing::PaintRoundedRectWithRadius(
488 aBackendData
, focusRect
, sTransparent
, innerColor
, strokeWidth
,
489 strokeRadius
, aDpiRatio
);
491 strokeWidth
= CSSCoord(1.0f
);
493 LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth
, aDpiRatio
));
494 strokeRadius
+= strokeWidth
;
495 focusRect
.Inflate(strokeWidthDevPx
);
497 ThemeDrawing::PaintRoundedRectWithRadius(
498 aBackendData
, focusRect
, sTransparent
, middleColor
, strokeWidth
,
499 strokeRadius
, aDpiRatio
);
501 strokeWidth
= CSSCoord(2.0f
);
503 LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(strokeWidth
, aDpiRatio
));
504 strokeRadius
+= strokeWidth
;
505 focusRect
.Inflate(strokeWidthDevPx
);
507 ThemeDrawing::PaintRoundedRectWithRadius(
508 aBackendData
, focusRect
, sTransparent
, outerColor
, strokeWidth
,
509 strokeRadius
, aDpiRatio
);
512 void Theme::PaintCheckboxControl(DrawTarget
& aDrawTarget
,
513 const LayoutDeviceRect
& aRect
,
514 const ElementState
& aState
,
515 const Colors
& aColors
, DPIRatio aDpiRatio
) {
516 auto [backgroundColor
, borderColor
, checkColor
] =
517 ComputeCheckboxColors(aState
, StyleAppearance::Checkbox
, aColors
);
519 const CSSCoord radius
= 2.0f
;
520 CSSCoord borderWidth
= kCheckboxRadioBorderWidth
;
521 if (backgroundColor
== borderColor
) {
524 ThemeDrawing::PaintRoundedRectWithRadius(aDrawTarget
, aRect
,
525 backgroundColor
, borderColor
,
526 borderWidth
, radius
, aDpiRatio
);
529 if (aState
.HasState(ElementState::INDETERMINATE
)) {
530 PaintIndeterminateMark(aDrawTarget
, aRect
, checkColor
);
531 } else if (aState
.HasState(ElementState::CHECKED
)) {
532 PaintCheckMark(aDrawTarget
, aRect
, checkColor
);
535 if (aState
.HasState(ElementState::FOCUSRING
)) {
536 PaintRoundedFocusRect(aDrawTarget
, aRect
, aColors
, aDpiRatio
, 5.0f
, 1.0f
);
540 constexpr CSSCoord kCheckboxRadioContentBoxSize
= 10.0f
;
541 constexpr CSSCoord kCheckboxRadioBorderBoxSize
=
542 kCheckboxRadioContentBoxSize
+ kCheckboxRadioBorderWidth
* 2.0f
;
544 void Theme::PaintCheckMark(DrawTarget
& aDrawTarget
,
545 const LayoutDeviceRect
& aRect
,
546 const sRGBColor
& aColor
) {
547 // Points come from the coordinates on a 14X14 (kCheckboxRadioBorderBoxSize)
548 // unit box centered at 0,0
549 const float checkPolygonX
[] = {-4.5f
, -1.5f
, -0.5f
, 5.0f
, 4.75f
,
550 3.5f
, -0.5f
, -1.5f
, -3.5f
};
551 const float checkPolygonY
[] = {0.5f
, 4.0f
, 4.0f
, -2.5f
, -4.0f
,
552 -4.0f
, 1.0f
, 1.25f
, -1.0f
};
553 const int32_t checkNumPoints
= sizeof(checkPolygonX
) / sizeof(float);
555 ThemeDrawing::ScaleToFillRect(aRect
, kCheckboxRadioBorderBoxSize
);
556 auto center
= aRect
.Center().ToUnknownPoint();
558 RefPtr
<PathBuilder
> builder
= aDrawTarget
.CreatePathBuilder();
559 Point p
= center
+ Point(checkPolygonX
[0] * scale
, checkPolygonY
[0] * scale
);
561 for (int32_t i
= 1; i
< checkNumPoints
; i
++) {
562 p
= center
+ Point(checkPolygonX
[i
] * scale
, checkPolygonY
[i
] * scale
);
565 RefPtr
<Path
> path
= builder
->Finish();
567 aDrawTarget
.Fill(path
, ColorPattern(ToDeviceColor(aColor
)));
570 void Theme::PaintIndeterminateMark(DrawTarget
& aDrawTarget
,
571 const LayoutDeviceRect
& aRect
,
572 const sRGBColor
& aColor
) {
573 const CSSCoord borderWidth
= 2.0f
;
575 ThemeDrawing::ScaleToFillRect(aRect
, kCheckboxRadioBorderBoxSize
);
577 Rect rect
= aRect
.ToUnknownRect();
578 rect
.y
+= (rect
.height
/ 2) - (borderWidth
* scale
/ 2);
579 rect
.height
= borderWidth
* scale
;
580 rect
.x
+= (borderWidth
* scale
) + (borderWidth
* scale
/ 8);
581 rect
.width
-= ((borderWidth
* scale
) + (borderWidth
* scale
/ 8)) * 2;
583 aDrawTarget
.FillRect(rect
, ColorPattern(ToDeviceColor(aColor
)));
586 template <typename PaintBackendData
>
587 void Theme::PaintStrokedCircle(PaintBackendData
& aPaintData
,
588 const LayoutDeviceRect
& aRect
,
589 const sRGBColor
& aBackgroundColor
,
590 const sRGBColor
& aBorderColor
,
591 const CSSCoord aBorderWidth
,
592 DPIRatio aDpiRatio
) {
593 auto radius
= LayoutDeviceCoord(aRect
.Size().width
) / aDpiRatio
;
594 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, aRect
, aBackgroundColor
,
595 aBorderColor
, aBorderWidth
, radius
,
599 void Theme::PaintCircleShadow(WebRenderBackendData
& aWrData
,
600 const LayoutDeviceRect
& aBoxRect
,
601 const LayoutDeviceRect
& aClipRect
,
602 float aShadowAlpha
, const CSSPoint
& aShadowOffset
,
603 CSSCoord aShadowBlurStdDev
, DPIRatio aDpiRatio
) {
604 const bool kBackfaceIsVisible
= true;
605 const LayoutDeviceCoord stdDev
= aShadowBlurStdDev
* aDpiRatio
;
606 const LayoutDevicePoint shadowOffset
= aShadowOffset
* aDpiRatio
;
607 const IntSize inflation
=
608 gfxAlphaBoxBlur::CalculateBlurRadius(gfxPoint(stdDev
, stdDev
));
609 LayoutDeviceRect shadowRect
= aBoxRect
;
610 shadowRect
.MoveBy(shadowOffset
);
611 shadowRect
.Inflate(inflation
.width
, inflation
.height
);
612 const auto boxRect
= wr::ToLayoutRect(aBoxRect
);
613 aWrData
.mBuilder
.PushBoxShadow(
614 wr::ToLayoutRect(shadowRect
), wr::ToLayoutRect(aClipRect
),
615 kBackfaceIsVisible
, boxRect
,
616 wr::ToLayoutVector2D(aShadowOffset
* aDpiRatio
),
617 wr::ToColorF(DeviceColor(0.0f
, 0.0f
, 0.0f
, aShadowAlpha
)), stdDev
,
618 /* aSpread = */ 0.0f
,
619 wr::ToBorderRadius(gfx::RectCornerRadii(aBoxRect
.Size().width
)),
620 wr::BoxShadowClipMode::Outset
);
623 void Theme::PaintCircleShadow(DrawTarget
& aDrawTarget
,
624 const LayoutDeviceRect
& aBoxRect
,
625 const LayoutDeviceRect
& aClipRect
,
626 float aShadowAlpha
, const CSSPoint
& aShadowOffset
,
627 CSSCoord aShadowBlurStdDev
, DPIRatio aDpiRatio
) {
628 Float stdDev
= aShadowBlurStdDev
* aDpiRatio
;
629 Point offset
= (aShadowOffset
* aDpiRatio
).ToUnknownPoint();
631 RefPtr
<FilterNode
> blurFilter
=
632 aDrawTarget
.CreateFilter(FilterType::GAUSSIAN_BLUR
);
637 blurFilter
->SetAttribute(ATT_GAUSSIAN_BLUR_STD_DEVIATION
, stdDev
);
640 gfxAlphaBoxBlur::CalculateBlurRadius(gfxPoint(stdDev
, stdDev
));
641 Rect inflatedRect
= aBoxRect
.ToUnknownRect();
642 inflatedRect
.Inflate(inflation
.width
, inflation
.height
);
643 Rect sourceRectInFilterSpace
=
644 inflatedRect
- aBoxRect
.TopLeft().ToUnknownPoint();
645 Point destinationPointOfSourceRect
= inflatedRect
.TopLeft() + offset
;
647 IntSize dtSize
= RoundedToInt(aBoxRect
.Size().ToUnknownSize());
648 RefPtr
<DrawTarget
> ellipseDT
= aDrawTarget
.CreateSimilarDrawTargetForFilter(
649 dtSize
, SurfaceFormat::A8
, blurFilter
, blurFilter
,
650 sourceRectInFilterSpace
, destinationPointOfSourceRect
);
655 AutoClipRect
clipRect(aDrawTarget
, aClipRect
);
657 RefPtr
<Path
> ellipse
= MakePathForEllipse(
658 *ellipseDT
, (aBoxRect
- aBoxRect
.TopLeft()).Center().ToUnknownPoint(),
659 aBoxRect
.Size().ToUnknownSize());
660 ellipseDT
->Fill(ellipse
,
661 ColorPattern(DeviceColor(0.0f
, 0.0f
, 0.0f
, aShadowAlpha
)));
662 RefPtr
<SourceSurface
> ellipseSurface
= ellipseDT
->Snapshot();
664 blurFilter
->SetInput(IN_GAUSSIAN_BLUR_IN
, ellipseSurface
);
665 aDrawTarget
.DrawFilter(blurFilter
, sourceRectInFilterSpace
,
666 destinationPointOfSourceRect
);
669 template <typename PaintBackendData
>
670 void Theme::PaintRadioControl(PaintBackendData
& aPaintData
,
671 const LayoutDeviceRect
& aRect
,
672 const ElementState
& aState
, const Colors
& aColors
,
673 DPIRatio aDpiRatio
) {
674 auto [backgroundColor
, borderColor
, checkColor
] =
675 ComputeCheckboxColors(aState
, StyleAppearance::Radio
, aColors
);
677 CSSCoord borderWidth
= kCheckboxRadioBorderWidth
;
678 if (backgroundColor
== borderColor
) {
681 PaintStrokedCircle(aPaintData
, aRect
, backgroundColor
, borderColor
,
682 borderWidth
, aDpiRatio
);
685 if (aState
.HasState(ElementState::CHECKED
)) {
686 LayoutDeviceRect
rect(aRect
);
687 auto width
= LayoutDeviceCoord(
688 ThemeDrawing::SnapBorderWidth(kCheckboxRadioBorderWidth
, aDpiRatio
));
691 PaintStrokedCircle(aPaintData
, rect
, backgroundColor
, checkColor
,
692 kCheckboxRadioBorderWidth
, aDpiRatio
);
695 if (aState
.HasState(ElementState::FOCUSRING
)) {
696 PaintRoundedFocusRect(aPaintData
, aRect
, aColors
, aDpiRatio
, 5.0f
, 1.0f
);
700 template <typename PaintBackendData
>
701 void Theme::PaintTextField(PaintBackendData
& aPaintData
,
702 const LayoutDeviceRect
& aRect
,
703 const ElementState
& aState
, const Colors
& aColors
,
704 DPIRatio aDpiRatio
) {
705 auto [backgroundColor
, borderColor
] =
706 ComputeTextfieldColors(aState
, aColors
, OutlineCoversBorder::Yes
);
708 const CSSCoord radius
= 2.0f
;
710 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, aRect
, backgroundColor
,
711 borderColor
, kTextFieldBorderWidth
,
714 if (aState
.HasState(ElementState::FOCUSRING
)) {
715 PaintRoundedFocusRect(aPaintData
, aRect
, aColors
, aDpiRatio
,
716 radius
+ kTextFieldBorderWidth
,
717 -kTextFieldBorderWidth
);
721 template <typename PaintBackendData
>
722 void Theme::PaintListbox(PaintBackendData
& aPaintData
,
723 const LayoutDeviceRect
& aRect
,
724 const ElementState
& aState
, const Colors
& aColors
,
725 DPIRatio aDpiRatio
) {
726 const CSSCoord radius
= 2.0f
;
727 auto [backgroundColor
, borderColor
] =
728 ComputeTextfieldColors(aState
, aColors
, OutlineCoversBorder::Yes
);
730 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, aRect
, backgroundColor
,
731 borderColor
, kMenulistBorderWidth
,
734 if (aState
.HasState(ElementState::FOCUSRING
)) {
735 PaintRoundedFocusRect(aPaintData
, aRect
, aColors
, aDpiRatio
,
736 radius
+ kMenulistBorderWidth
, -kMenulistBorderWidth
);
740 template <typename PaintBackendData
>
741 void Theme::PaintMenulist(PaintBackendData
& aDrawTarget
,
742 const LayoutDeviceRect
& aRect
,
743 const ElementState
& aState
, const Colors
& aColors
,
744 DPIRatio aDpiRatio
) {
745 const CSSCoord radius
= 4.0f
;
746 auto [backgroundColor
, borderColor
] = ComputeButtonColors(aState
, aColors
);
748 ThemeDrawing::PaintRoundedRectWithRadius(aDrawTarget
, aRect
, backgroundColor
,
749 borderColor
, kMenulistBorderWidth
,
752 if (aState
.HasState(ElementState::FOCUSRING
)) {
753 PaintRoundedFocusRect(aDrawTarget
, aRect
, aColors
, aDpiRatio
,
754 radius
+ kMenulistBorderWidth
, -kMenulistBorderWidth
);
758 enum class PhysicalArrowDirection
{
764 void Theme::PaintMenulistArrow(nsIFrame
* aFrame
, DrawTarget
& aDrawTarget
,
765 const LayoutDeviceRect
& aRect
) {
766 // not const: these may be negated in-place below
767 float polygonX
[] = {-4.0f
, -0.5f
, 0.5f
, 4.0f
, 4.0f
,
768 3.0f
, 0.0f
, 0.0f
, -3.0f
, -4.0f
};
769 float polygonY
[] = {-1, 3.0f
, 3.0f
, -1.0f
, -2.0f
,
770 -2.0f
, 1.5f
, 1.5f
, -2.0f
, -2.0f
};
772 const float kPolygonSize
= kMinimumDropdownArrowButtonWidth
;
773 const auto direction
= [&] {
774 const auto wm
= aFrame
->GetWritingMode();
775 switch (wm
.GetBlockDir()) {
776 case WritingMode::BlockDir::eBlockLR
:
777 return PhysicalArrowDirection::Right
;
778 case WritingMode::BlockDir::eBlockRL
:
779 return PhysicalArrowDirection::Left
;
780 case WritingMode::BlockDir::eBlockTB
:
781 return PhysicalArrowDirection::Bottom
;
783 MOZ_ASSERT_UNREACHABLE("Unknown direction?");
784 return PhysicalArrowDirection::Bottom
;
787 auto const [xs
, ys
] = [&] {
788 using Pair
= std::pair
<const float*, const float*>;
790 case PhysicalArrowDirection::Left
:
791 // rotate 90°: [[0,1],[-1,0]]
792 for (float& f
: polygonY
) {
795 return Pair(polygonY
, polygonX
);
797 case PhysicalArrowDirection::Right
:
798 // rotate 270°: [[0,-1],[1,0]]
799 for (float& f
: polygonX
) {
802 return Pair(polygonY
, polygonX
);
804 case PhysicalArrowDirection::Bottom
:
805 // rotate 0°: [[1,0],[0,1]]
806 return Pair(polygonX
, polygonY
);
808 MOZ_ASSERT_UNREACHABLE("Unknown direction?");
809 return Pair(polygonX
, polygonY
);
812 const auto arrowColor
= sRGBColor::FromABGR(
813 nsLayoutUtils::GetColor(aFrame
, &nsStyleText::mWebkitTextFillColor
));
814 ThemeDrawing::PaintArrow(aDrawTarget
, aRect
, xs
, ys
, kPolygonSize
,
815 ArrayLength(polygonX
), arrowColor
);
818 void Theme::PaintSpinnerButton(nsIFrame
* aFrame
, DrawTarget
& aDrawTarget
,
819 const LayoutDeviceRect
& aRect
,
820 const ElementState
& aState
,
821 StyleAppearance aAppearance
,
822 const Colors
& aColors
, DPIRatio aDpiRatio
) {
823 auto [backgroundColor
, borderColor
] = ComputeButtonColors(aState
, aColors
);
825 aDrawTarget
.FillRect(aRect
.ToUnknownRect(),
826 ColorPattern(ToDeviceColor(backgroundColor
)));
828 const float kPolygonX
[] = {-3.5f
, -0.5f
, 0.5f
, 3.5f
, 3.5f
,
829 2.5f
, 0.0f
, 0.0f
, -2.5f
, -3.5f
};
830 float polygonY
[] = {-1.5f
, 1.5f
, 1.5f
, -1.5f
, -2.5f
,
831 -2.5f
, 0.0f
, 0.0f
, -2.5f
, -2.5f
};
833 const float kPolygonSize
= kMinimumSpinnerButtonHeight
;
834 if (aAppearance
== StyleAppearance::SpinnerUpbutton
) {
835 for (auto& coord
: polygonY
) {
840 ThemeDrawing::PaintArrow(aDrawTarget
, aRect
, kPolygonX
, polygonY
,
841 kPolygonSize
, ArrayLength(kPolygonX
), borderColor
);
844 template <typename PaintBackendData
>
845 void Theme::PaintRange(nsIFrame
* aFrame
, PaintBackendData
& aPaintData
,
846 const LayoutDeviceRect
& aRect
,
847 const ElementState
& aState
, const Colors
& aColors
,
848 DPIRatio aDpiRatio
, bool aHorizontal
) {
849 nsRangeFrame
* rangeFrame
= do_QueryFrame(aFrame
);
854 auto tickMarks
= rangeFrame
->TickMarks();
855 double progress
= rangeFrame
->GetValueAsFractionOfRange();
857 LayoutDeviceRect
thumbRect(0, 0, kMinimumRangeThumbSize
* aDpiRatio
,
858 kMinimumRangeThumbSize
* aDpiRatio
);
859 LayoutDeviceRect
progressClipRect(aRect
);
860 LayoutDeviceRect
trackClipRect(aRect
);
861 const LayoutDeviceCoord verticalSize
= kRangeHeight
* aDpiRatio
;
862 const LayoutDeviceCoord
tickMarkWidth(
863 ThemeDrawing::SnapBorderWidth(1.0f
, aDpiRatio
));
864 const LayoutDeviceCoord
tickMarkHeight(
865 ThemeDrawing::SnapBorderWidth(5.0f
, aDpiRatio
));
866 LayoutDevicePoint tickMarkOrigin
, tickMarkDirection
;
867 LayoutDeviceSize tickMarkSize
;
869 rect
.height
= verticalSize
;
870 rect
.y
= aRect
.y
+ (aRect
.height
- rect
.height
) / 2;
871 tickMarkSize
= LayoutDeviceSize(tickMarkWidth
, tickMarkHeight
);
872 thumbRect
.y
= aRect
.y
+ (aRect
.height
- thumbRect
.height
) / 2;
874 if (IsFrameRTL(aFrame
)) {
876 LayoutDevicePoint(aRect
.XMost() - thumbRect
.width
/ 2, aRect
.YMost());
877 tickMarkDirection
= LayoutDevicePoint(-1.0f
, 0.0f
);
879 aRect
.x
+ (aRect
.width
- thumbRect
.width
) * (1.0 - progress
);
880 float midPoint
= thumbRect
.Center().X();
881 trackClipRect
.SetBoxX(aRect
.X(), midPoint
);
882 progressClipRect
.SetBoxX(midPoint
, aRect
.XMost());
885 LayoutDevicePoint(aRect
.x
+ thumbRect
.width
/ 2, aRect
.YMost());
886 tickMarkDirection
= LayoutDevicePoint(1.0, 0.0f
);
887 thumbRect
.x
= aRect
.x
+ (aRect
.width
- thumbRect
.width
) * progress
;
888 float midPoint
= thumbRect
.Center().X();
889 progressClipRect
.SetBoxX(aRect
.X(), midPoint
);
890 trackClipRect
.SetBoxX(midPoint
, aRect
.XMost());
893 rect
.width
= verticalSize
;
894 rect
.x
= aRect
.x
+ (aRect
.width
- rect
.width
) / 2;
895 tickMarkOrigin
= LayoutDevicePoint(aRect
.XMost() - tickMarkHeight
/ 4,
896 aRect
.YMost() - thumbRect
.width
/ 2);
897 tickMarkDirection
= LayoutDevicePoint(0.0f
, -1.0f
);
898 tickMarkSize
= LayoutDeviceSize(tickMarkHeight
, tickMarkWidth
);
899 thumbRect
.x
= aRect
.x
+ (aRect
.width
- thumbRect
.width
) / 2;
901 if (rangeFrame
->IsUpwards()) {
903 aRect
.y
+ (aRect
.height
- thumbRect
.height
) * (1.0 - progress
);
904 float midPoint
= thumbRect
.Center().Y();
905 trackClipRect
.SetBoxY(aRect
.Y(), midPoint
);
906 progressClipRect
.SetBoxY(midPoint
, aRect
.YMost());
908 thumbRect
.y
= aRect
.y
+ (aRect
.height
- thumbRect
.height
) * progress
;
909 float midPoint
= thumbRect
.Center().Y();
910 trackClipRect
.SetBoxY(midPoint
, aRect
.YMost());
911 progressClipRect
.SetBoxY(aRect
.Y(), midPoint
);
915 const CSSCoord borderWidth
= 1.0f
;
916 const CSSCoord radius
= 3.0f
;
918 auto [progressColor
, progressBorderColor
] =
919 ComputeRangeProgressColors(aState
, aColors
);
920 auto [trackColor
, trackBorderColor
] =
921 ComputeRangeTrackColors(aState
, aColors
);
922 auto tickMarkColor
= trackBorderColor
;
924 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, rect
, progressClipRect
,
925 progressColor
, progressBorderColor
,
926 borderWidth
, radius
, aDpiRatio
);
928 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, rect
, trackClipRect
,
929 trackColor
, trackBorderColor
,
930 borderWidth
, radius
, aDpiRatio
);
932 if (!aState
.HasState(ElementState::DISABLED
)) {
933 // Ensure the shadow doesn't expand outside of our overflow rect declared in
934 // GetWidgetOverflow().
935 auto overflowRect
= aRect
;
936 overflowRect
.Inflate(CSSCoord(6.0f
) * aDpiRatio
);
938 PaintCircleShadow(aPaintData
, thumbRect
, overflowRect
, 0.3f
,
939 CSSPoint(0.0f
, 2.0f
), 2.0f
, aDpiRatio
);
942 tickMarkDirection
.x
*= aRect
.width
- thumbRect
.width
;
943 tickMarkDirection
.y
*= aRect
.height
- thumbRect
.height
;
945 LayoutDevicePoint(tickMarkSize
.width
, tickMarkSize
.height
) / 2;
946 auto tickMarkRect
= LayoutDeviceRect(tickMarkOrigin
, tickMarkSize
);
947 for (auto tickMark
: tickMarks
) {
948 auto tickMarkOffset
=
950 float(rangeFrame
->GetDoubleAsFractionOfRange(tickMark
));
951 ThemeDrawing::FillRect(aPaintData
, tickMarkRect
+ tickMarkOffset
,
955 // Draw the thumb on top.
956 const CSSCoord thumbBorderWidth
= 2.0f
;
957 auto [thumbColor
, thumbBorderColor
] =
958 ComputeRangeThumbColors(aState
, aColors
);
960 PaintStrokedCircle(aPaintData
, thumbRect
, thumbColor
, thumbBorderColor
,
961 thumbBorderWidth
, aDpiRatio
);
963 if (aState
.HasState(ElementState::FOCUSRING
)) {
964 PaintRoundedFocusRect(aPaintData
, aRect
, aColors
, aDpiRatio
, radius
, 1.0f
);
968 template <typename PaintBackendData
>
969 void Theme::PaintProgress(nsIFrame
* aFrame
, PaintBackendData
& aPaintData
,
970 const LayoutDeviceRect
& aRect
,
971 const ElementState
& aState
, const Colors
& aColors
,
972 DPIRatio aDpiRatio
, bool aIsMeter
) {
973 const CSSCoord borderWidth
= 1.0f
;
974 const CSSCoord radius
= aIsMeter
? 6.0f
: 3.0f
;
976 LayoutDeviceRect
rect(aRect
);
977 const LayoutDeviceCoord thickness
=
978 (aIsMeter
? kMeterHeight
: kProgressbarHeight
) * aDpiRatio
;
980 const bool isHorizontal
= !nsNativeTheme::IsVerticalProgress(aFrame
);
982 // Center it vertically.
983 rect
.y
+= (rect
.height
- thickness
) / 2;
984 rect
.height
= thickness
;
986 // Center it horizontally.
987 rect
.x
+= (rect
.width
- thickness
) / 2;
988 rect
.width
= thickness
;
992 // Paint the track, unclipped.
993 auto [backgroundColor
, borderColor
] = ComputeProgressTrackColors(aColors
);
994 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, rect
, rect
,
995 backgroundColor
, borderColor
,
996 borderWidth
, radius
, aDpiRatio
);
999 // Now paint the chunk, clipped as needed.
1000 LayoutDeviceRect clipRect
= rect
;
1001 if (aState
.HasState(ElementState::INDETERMINATE
)) {
1002 // For indeterminate progress, we paint an animated chunk of 1/3 of the
1005 // Animation speed and math borrowed from GTK.
1006 const LayoutDeviceCoord size
= isHorizontal
? rect
.width
: rect
.height
;
1007 const LayoutDeviceCoord barSize
= size
* 0.3333f
;
1008 const LayoutDeviceCoord travel
= 2.0f
* (size
- barSize
);
1010 // Period equals to travel / pixelsPerMillisecond where pixelsPerMillisecond
1011 // equals progressSize / 1000.0. This is equivalent to 1600.
1012 const unsigned kPeriod
= 1600;
1014 const int t
= PR_IntervalToMilliseconds(PR_IntervalNow()) % kPeriod
;
1015 const LayoutDeviceCoord dx
= travel
* float(t
) / float(kPeriod
);
1017 rect
.width
= barSize
;
1018 rect
.x
+= (dx
< travel
* .5f
) ? dx
: travel
- dx
;
1020 rect
.height
= barSize
;
1021 rect
.y
+= (dx
< travel
* .5f
) ? dx
: travel
- dx
;
1024 // Queue the next frame if needed.
1025 if (!QueueAnimatedContentForRefresh(aFrame
->GetContent(), 60)) {
1026 NS_WARNING("Couldn't refresh indeterminate <progress>");
1029 // This is the progress chunk, clip it to the right amount.
1030 double position
= [&] {
1032 auto* meter
= dom::HTMLMeterElement::FromNode(aFrame
->GetContent());
1036 return meter
->Position();
1038 auto* progress
= dom::HTMLProgressElement::FromNode(aFrame
->GetContent());
1042 return progress
->Position();
1045 double clipWidth
= rect
.width
* position
;
1046 clipRect
.width
= clipWidth
;
1047 if (IsFrameRTL(aFrame
)) {
1048 clipRect
.x
+= rect
.width
- clipWidth
;
1051 double clipHeight
= rect
.height
* position
;
1052 clipRect
.height
= clipHeight
;
1053 clipRect
.y
+= rect
.height
- clipHeight
;
1057 auto [backgroundColor
, borderColor
] =
1058 aIsMeter
? ComputeMeterchunkColors(aState
, aColors
)
1059 : ComputeProgressColors(aColors
);
1060 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, rect
, clipRect
,
1061 backgroundColor
, borderColor
,
1062 borderWidth
, radius
, aDpiRatio
);
1065 template <typename PaintBackendData
>
1066 void Theme::PaintButton(nsIFrame
* aFrame
, PaintBackendData
& aPaintData
,
1067 const LayoutDeviceRect
& aRect
,
1068 const ElementState
& aState
, const Colors
& aColors
,
1069 DPIRatio aDpiRatio
) {
1070 const CSSCoord radius
= 4.0f
;
1071 auto [backgroundColor
, borderColor
] =
1072 ComputeButtonColors(aState
, aColors
, aFrame
);
1074 ThemeDrawing::PaintRoundedRectWithRadius(aPaintData
, aRect
, backgroundColor
,
1075 borderColor
, kButtonBorderWidth
,
1078 if (aState
.HasState(ElementState::FOCUSRING
)) {
1079 PaintRoundedFocusRect(aPaintData
, aRect
, aColors
, aDpiRatio
,
1080 radius
+ kButtonBorderWidth
, -kButtonBorderWidth
);
1085 Theme::DrawWidgetBackground(gfxContext
* aContext
, nsIFrame
* aFrame
,
1086 StyleAppearance aAppearance
, const nsRect
& aRect
,
1087 const nsRect
& /* aDirtyRect */,
1088 DrawOverflow aDrawOverflow
) {
1089 if (!DoDrawWidgetBackground(*aContext
->GetDrawTarget(), aFrame
, aAppearance
,
1090 aRect
, aDrawOverflow
)) {
1091 return NS_ERROR_NOT_IMPLEMENTED
;
1096 bool Theme::CreateWebRenderCommandsForWidget(
1097 mozilla::wr::DisplayListBuilder
& aBuilder
,
1098 mozilla::wr::IpcResourceUpdateQueue
& aResources
,
1099 const mozilla::layers::StackingContextHelper
& aSc
,
1100 mozilla::layers::RenderRootStateManager
* aManager
, nsIFrame
* aFrame
,
1101 StyleAppearance aAppearance
, const nsRect
& aRect
) {
1102 if (!StaticPrefs::widget_non_native_theme_webrender()) {
1105 WebRenderBackendData data
{aBuilder
, aResources
, aSc
, aManager
};
1106 return DoDrawWidgetBackground(data
, aFrame
, aAppearance
, aRect
,
1110 static LayoutDeviceRect
ToSnappedRect(const nsRect
& aRect
,
1111 nscoord aTwipsPerPixel
, DrawTarget
& aDt
) {
1112 return LayoutDeviceRect::FromUnknownRect(
1113 NSRectToSnappedRect(aRect
, aTwipsPerPixel
, aDt
));
1116 static LayoutDeviceRect
ToSnappedRect(const nsRect
& aRect
,
1117 nscoord aTwipsPerPixel
,
1118 WebRenderBackendData
& aDt
) {
1119 // TODO: Do we need to do any more snapping here?
1120 return LayoutDeviceRect::FromAppUnits(aRect
, aTwipsPerPixel
);
1123 static ScrollbarDrawing::ScrollbarKind
ComputeScrollbarKind(
1124 nsIFrame
* aFrame
, bool aIsHorizontal
) {
1125 if (aIsHorizontal
) {
1126 return ScrollbarDrawing::ScrollbarKind::Horizontal
;
1128 nsIFrame
* scrollbar
= ScrollbarDrawing::GetParentScrollbarFrame(aFrame
);
1129 if (NS_WARN_IF(!scrollbar
)) {
1130 return ScrollbarDrawing::ScrollbarKind::VerticalRight
;
1132 MOZ_ASSERT(scrollbar
->IsScrollbarFrame());
1133 nsIScrollbarMediator
* sm
=
1134 static_cast<nsScrollbarFrame
*>(scrollbar
)->GetScrollbarMediator();
1135 if (NS_WARN_IF(!sm
)) {
1136 return ScrollbarDrawing::ScrollbarKind::VerticalRight
;
1138 return sm
->IsScrollbarOnRight()
1139 ? ScrollbarDrawing::ScrollbarKind::VerticalRight
1140 : ScrollbarDrawing::ScrollbarKind::VerticalLeft
;
1143 static ScrollbarDrawing::ScrollbarKind
ComputeScrollbarKindForScrollCorner(
1145 nsIScrollableFrame
* sf
= do_QueryFrame(aFrame
->GetParent());
1147 return ScrollbarDrawing::ScrollbarKind::VerticalRight
;
1149 return sf
->IsScrollbarOnRight()
1150 ? ScrollbarDrawing::ScrollbarKind::VerticalRight
1151 : ScrollbarDrawing::ScrollbarKind::VerticalLeft
;
1154 template <typename PaintBackendData
>
1155 bool Theme::DoDrawWidgetBackground(PaintBackendData
& aPaintData
,
1157 StyleAppearance aAppearance
,
1158 const nsRect
& aRect
,
1159 DrawOverflow aDrawOverflow
) {
1160 static_assert(std::is_same_v
<PaintBackendData
, DrawTarget
> ||
1161 std::is_same_v
<PaintBackendData
, WebRenderBackendData
>);
1163 const nsPresContext
* pc
= aFrame
->PresContext();
1164 const nscoord twipsPerPixel
= pc
->AppUnitsPerDevPixel();
1165 const auto devPxRect
= ToSnappedRect(aRect
, twipsPerPixel
, aPaintData
);
1167 const DocumentState docState
= pc
->Document()->State();
1168 ElementState elementState
= GetContentState(aFrame
, aAppearance
);
1169 // Paint the outline iff we're asked to draw overflow and we have
1170 // outline-style: auto.
1171 if (aDrawOverflow
== DrawOverflow::Yes
&&
1172 aFrame
->StyleOutline()->mOutlineStyle
.IsAuto()) {
1173 elementState
|= ElementState::FOCUSRING
;
1175 elementState
&= ~ElementState::FOCUSRING
;
1178 // Hack to avoid skia fuzziness: Add a dummy clip if the widget doesn't
1179 // overflow devPxRect.
1180 Maybe
<AutoClipRect
> maybeClipRect
;
1181 if constexpr (std::is_same_v
<PaintBackendData
, DrawTarget
>) {
1182 if (aAppearance
!= StyleAppearance::FocusOutline
&&
1183 aAppearance
!= StyleAppearance::Range
&&
1184 !elementState
.HasState(ElementState::FOCUSRING
)) {
1185 maybeClipRect
.emplace(aPaintData
, devPxRect
);
1189 const Colors
colors(aFrame
, aAppearance
);
1190 DPIRatio dpiRatio
= GetDPIRatio(aFrame
, aAppearance
);
1192 switch (aAppearance
) {
1193 case StyleAppearance::Radio
: {
1194 auto rect
= CheckBoxRadioRect(devPxRect
);
1195 PaintRadioControl(aPaintData
, rect
, elementState
, colors
, dpiRatio
);
1198 case StyleAppearance::Checkbox
: {
1199 if constexpr (std::is_same_v
<PaintBackendData
, WebRenderBackendData
>) {
1200 // TODO: Need to figure out how to best draw this using WR.
1203 auto rect
= CheckBoxRadioRect(devPxRect
);
1204 PaintCheckboxControl(aPaintData
, rect
, elementState
, colors
, dpiRatio
);
1208 case StyleAppearance::Textarea
:
1209 case StyleAppearance::Textfield
:
1210 case StyleAppearance::NumberInput
:
1211 PaintTextField(aPaintData
, devPxRect
, elementState
, colors
, dpiRatio
);
1213 case StyleAppearance::Listbox
:
1214 PaintListbox(aPaintData
, devPxRect
, elementState
, colors
, dpiRatio
);
1216 case StyleAppearance::MenulistButton
:
1217 case StyleAppearance::Menulist
:
1218 PaintMenulist(aPaintData
, devPxRect
, elementState
, colors
, dpiRatio
);
1220 case StyleAppearance::MozMenulistArrowButton
:
1221 if constexpr (std::is_same_v
<PaintBackendData
, WebRenderBackendData
>) {
1222 // TODO: Need to figure out how to best draw this using WR.
1225 PaintMenulistArrow(aFrame
, aPaintData
, devPxRect
);
1228 case StyleAppearance::Tooltip
: {
1229 const CSSCoord
strokeWidth(1.0f
);
1230 const CSSCoord
strokeRadius(2.0f
);
1231 ThemeDrawing::PaintRoundedRectWithRadius(
1232 aPaintData
, devPxRect
,
1233 colors
.System(StyleSystemColor::Infobackground
),
1234 colors
.System(StyleSystemColor::Infotext
), strokeWidth
, strokeRadius
,
1238 case StyleAppearance::SpinnerUpbutton
:
1239 case StyleAppearance::SpinnerDownbutton
:
1240 if constexpr (std::is_same_v
<PaintBackendData
, WebRenderBackendData
>) {
1241 // TODO: Need to figure out how to best draw this using WR.
1244 PaintSpinnerButton(aFrame
, aPaintData
, devPxRect
, elementState
,
1245 aAppearance
, colors
, dpiRatio
);
1248 case StyleAppearance::Range
:
1249 PaintRange(aFrame
, aPaintData
, devPxRect
, elementState
, colors
, dpiRatio
,
1250 IsRangeHorizontal(aFrame
));
1252 case StyleAppearance::RangeThumb
:
1253 // Painted as part of StyleAppearance::Range.
1255 case StyleAppearance::ProgressBar
:
1256 PaintProgress(aFrame
, aPaintData
, devPxRect
, elementState
, colors
,
1258 /* aIsMeter = */ false);
1260 case StyleAppearance::Progresschunk
:
1261 /* Painted as part of the progress bar */
1263 case StyleAppearance::Meter
:
1264 PaintProgress(aFrame
, aPaintData
, devPxRect
, elementState
, colors
,
1266 /* aIsMeter = */ true);
1268 case StyleAppearance::Meterchunk
:
1269 /* Painted as part of the meter bar */
1271 case StyleAppearance::ScrollbarthumbHorizontal
:
1272 case StyleAppearance::ScrollbarthumbVertical
: {
1274 aAppearance
== StyleAppearance::ScrollbarthumbHorizontal
;
1275 auto kind
= ComputeScrollbarKind(aFrame
, isHorizontal
);
1276 return GetScrollbarDrawing().PaintScrollbarThumb(
1277 aPaintData
, devPxRect
, kind
, aFrame
,
1278 *nsLayoutUtils::StyleForScrollbar(aFrame
), elementState
, docState
,
1281 case StyleAppearance::ScrollbartrackHorizontal
:
1282 case StyleAppearance::ScrollbartrackVertical
: {
1284 aAppearance
== StyleAppearance::ScrollbartrackHorizontal
;
1285 auto kind
= ComputeScrollbarKind(aFrame
, isHorizontal
);
1286 return GetScrollbarDrawing().PaintScrollbarTrack(
1287 aPaintData
, devPxRect
, kind
, aFrame
,
1288 *nsLayoutUtils::StyleForScrollbar(aFrame
), docState
, colors
,
1291 case StyleAppearance::ScrollbarHorizontal
:
1292 case StyleAppearance::ScrollbarVertical
: {
1293 bool isHorizontal
= aAppearance
== StyleAppearance::ScrollbarHorizontal
;
1294 auto kind
= ComputeScrollbarKind(aFrame
, isHorizontal
);
1295 return GetScrollbarDrawing().PaintScrollbar(
1296 aPaintData
, devPxRect
, kind
, aFrame
,
1297 *nsLayoutUtils::StyleForScrollbar(aFrame
), elementState
, docState
,
1300 case StyleAppearance::Scrollcorner
: {
1301 auto kind
= ComputeScrollbarKindForScrollCorner(aFrame
);
1302 return GetScrollbarDrawing().PaintScrollCorner(
1303 aPaintData
, devPxRect
, kind
, aFrame
,
1304 *nsLayoutUtils::StyleForScrollbar(aFrame
), docState
, colors
,
1307 case StyleAppearance::ScrollbarbuttonUp
:
1308 case StyleAppearance::ScrollbarbuttonDown
:
1309 case StyleAppearance::ScrollbarbuttonLeft
:
1310 case StyleAppearance::ScrollbarbuttonRight
: {
1311 // For scrollbar-width:thin, we don't display the buttons.
1312 if (!ScrollbarDrawing::IsScrollbarWidthThin(aFrame
)) {
1313 if constexpr (std::is_same_v
<PaintBackendData
, WebRenderBackendData
>) {
1314 // TODO: Need to figure out how to best draw this using WR.
1318 aAppearance
== StyleAppearance::ScrollbarbuttonLeft
||
1319 aAppearance
== StyleAppearance::ScrollbarbuttonRight
;
1320 auto kind
= ComputeScrollbarKind(aFrame
, isHorizontal
);
1321 GetScrollbarDrawing().PaintScrollbarButton(
1322 aPaintData
, aAppearance
, devPxRect
, kind
, aFrame
,
1323 *nsLayoutUtils::StyleForScrollbar(aFrame
), elementState
, docState
,
1329 case StyleAppearance::Button
:
1330 PaintButton(aFrame
, aPaintData
, devPxRect
, elementState
, colors
,
1333 case StyleAppearance::FocusOutline
:
1334 PaintAutoStyleOutline(aFrame
, aPaintData
, devPxRect
, colors
, dpiRatio
);
1337 // Various appearance values are used for XUL elements. Normally these
1338 // will not be available in content documents (and thus in the content
1339 // processes where the native basic theme can be used), but tests are
1340 // run with the remote XUL pref enabled and so we can get in here. So
1341 // we just return an error rather than assert.
1348 template <typename PaintBackendData
>
1349 void Theme::PaintAutoStyleOutline(nsIFrame
* aFrame
,
1350 PaintBackendData
& aPaintData
,
1351 const LayoutDeviceRect
& aRect
,
1352 const Colors
& aColors
, DPIRatio aDpiRatio
) {
1353 const auto& accentColor
= aColors
.Accent();
1354 const bool solid
= StaticPrefs::widget_non_native_theme_solid_outline_style();
1355 LayoutDeviceCoord
strokeWidth(ThemeDrawing::SnapBorderWidth(2.0f
, aDpiRatio
));
1357 LayoutDeviceRect
rect(aRect
);
1358 rect
.Inflate(strokeWidth
);
1360 const nscoord a2d
= aFrame
->PresContext()->AppUnitsPerDevPixel();
1361 nscoord cssOffset
= aFrame
->StyleOutline()->mOutlineOffset
.ToAppUnits();
1362 nscoord cssRadii
[8] = {0};
1363 if (!aFrame
->GetBorderRadii(cssRadii
)) {
1364 const auto twoPixels
= 2 * AppUnitsPerCSSPixel();
1365 const nscoord radius
=
1366 cssOffset
>= 0 ? twoPixels
: std::max(twoPixels
+ cssOffset
, 0);
1367 cssOffset
= -twoPixels
;
1368 for (auto& r
: cssRadii
) {
1373 auto offset
= LayoutDevicePixel::FromAppUnits(cssOffset
, a2d
);
1374 RectCornerRadii innerRadii
;
1375 nsCSSRendering::ComputePixelRadii(cssRadii
, a2d
, &innerRadii
);
1377 // NOTE(emilio): This doesn't use PaintRoundedRectWithRadius because we need
1378 // to support arbitrary radii.
1379 auto DrawRect
= [&](const sRGBColor
& aColor
) {
1380 RectCornerRadii outerRadii
;
1381 if constexpr (std::is_same_v
<PaintBackendData
, WebRenderBackendData
>) {
1382 const Float widths
[4] = {strokeWidth
+ offset
, strokeWidth
+ offset
,
1383 strokeWidth
+ offset
, strokeWidth
+ offset
};
1384 nsCSSBorderRenderer::ComputeOuterRadii(innerRadii
, widths
, &outerRadii
);
1385 const auto dest
= wr::ToLayoutRect(rect
);
1387 wr::ToBorderSide(ToDeviceColor(aColor
), StyleBorderStyle::Solid
);
1388 const wr::BorderSide sides
[4] = {side
, side
, side
, side
};
1389 const bool kBackfaceIsVisible
= true;
1390 const auto wrWidths
= wr::ToBorderWidths(strokeWidth
, strokeWidth
,
1391 strokeWidth
, strokeWidth
);
1392 const auto wrRadius
= wr::ToBorderRadius(outerRadii
);
1393 aPaintData
.mBuilder
.PushBorder(dest
, dest
, kBackfaceIsVisible
, wrWidths
,
1394 {sides
, 4}, wrRadius
);
1396 const LayoutDeviceCoord halfWidth
= strokeWidth
* 0.5f
;
1397 const Float widths
[4] = {halfWidth
+ offset
, halfWidth
+ offset
,
1398 halfWidth
+ offset
, halfWidth
+ offset
};
1399 nsCSSBorderRenderer::ComputeOuterRadii(innerRadii
, widths
, &outerRadii
);
1400 LayoutDeviceRect
dest(rect
);
1401 dest
.Deflate(halfWidth
);
1403 MakePathForRoundedRect(aPaintData
, dest
.ToUnknownRect(), outerRadii
);
1404 aPaintData
.Stroke(path
, ColorPattern(ToDeviceColor(aColor
)),
1405 StrokeOptions(strokeWidth
));
1409 auto primaryColor
= aColors
.HighContrast()
1410 ? aColors
.System(StyleSystemColor::Selecteditem
)
1411 : accentColor
.Get();
1412 DrawRect(primaryColor
);
1418 offset
+= strokeWidth
;
1421 LayoutDeviceCoord(ThemeDrawing::SnapBorderWidth(1.0f
, aDpiRatio
));
1422 rect
.Inflate(strokeWidth
);
1424 auto secondaryColor
= aColors
.HighContrast()
1425 ? aColors
.System(StyleSystemColor::Canvastext
)
1426 : accentColor
.GetForeground();
1427 DrawRect(secondaryColor
);
1430 LayoutDeviceIntMargin
Theme::GetWidgetBorder(nsDeviceContext
* aContext
,
1432 StyleAppearance aAppearance
) {
1433 switch (aAppearance
) {
1434 case StyleAppearance::Textfield
:
1435 case StyleAppearance::Textarea
:
1436 case StyleAppearance::NumberInput
:
1437 case StyleAppearance::Listbox
:
1438 case StyleAppearance::Menulist
:
1439 case StyleAppearance::MenulistButton
:
1440 case StyleAppearance::Button
:
1441 // Return the border size from the UA sheet, even though what we paint
1442 // doesn't actually match that. We know this is the UA sheet border
1443 // because we disable native theming when different border widths are
1444 // specified by authors, see Theme::IsWidgetStyled.
1446 // The Rounded() bit is technically redundant, but needed to appease the
1447 // type system, we should always end up with full device pixels due to
1448 // round_border_to_device_pixels at style time.
1449 return LayoutDeviceIntMargin::FromAppUnits(
1450 aFrame
->StyleBorder()->GetComputedBorder(),
1451 aFrame
->PresContext()->AppUnitsPerDevPixel())
1453 case StyleAppearance::Checkbox
:
1454 case StyleAppearance::Radio
: {
1455 DPIRatio dpiRatio
= GetDPIRatio(aFrame
, aAppearance
);
1456 LayoutDeviceIntCoord w
=
1457 ThemeDrawing::SnapBorderWidth(kCheckboxRadioBorderWidth
, dpiRatio
);
1458 return LayoutDeviceIntMargin(w
, w
, w
, w
);
1461 return LayoutDeviceIntMargin();
1465 bool Theme::GetWidgetPadding(nsDeviceContext
* aContext
, nsIFrame
* aFrame
,
1466 StyleAppearance aAppearance
,
1467 LayoutDeviceIntMargin
* aResult
) {
1468 switch (aAppearance
) {
1469 // Radios and checkboxes return a fixed size in GetMinimumWidgetSize
1470 // and have a meaningful baseline, so they can't have
1471 // author-specified padding.
1472 case StyleAppearance::Radio
:
1473 case StyleAppearance::Checkbox
:
1474 aResult
->SizeTo(0, 0, 0, 0);
1482 bool Theme::GetWidgetOverflow(nsDeviceContext
* aContext
, nsIFrame
* aFrame
,
1483 StyleAppearance aAppearance
,
1484 nsRect
* aOverflowRect
) {
1485 CSSIntMargin overflow
;
1486 switch (aAppearance
) {
1487 case StyleAppearance::FocusOutline
: {
1488 // 2px * one segment, or 2px + 1px
1490 StaticPrefs::widget_non_native_theme_solid_outline_style() ? 2 : 3;
1491 overflow
.SizeTo(width
, width
, width
, width
);
1494 case StyleAppearance::Radio
:
1495 case StyleAppearance::Checkbox
:
1496 case StyleAppearance::Range
:
1497 // 2px for each outline segment, plus 1px separation, plus we paint with a
1498 // 1px extra offset, so 6px.
1499 overflow
.SizeTo(6, 6, 6, 6);
1501 case StyleAppearance::Textarea
:
1502 case StyleAppearance::Textfield
:
1503 case StyleAppearance::NumberInput
:
1504 case StyleAppearance::Listbox
:
1505 case StyleAppearance::MenulistButton
:
1506 case StyleAppearance::Menulist
:
1507 case StyleAppearance::Button
:
1508 // 2px for each segment, plus 1px separation, but we paint 1px inside
1509 // the border area so 4px overflow.
1510 overflow
.SizeTo(4, 4, 4, 4);
1516 // TODO: This should convert from device pixels to app units, not from CSS
1517 // pixels. And it should take the dpi ratio into account.
1518 // Using CSS pixels can cause the overflow to be too small if the page is
1520 aOverflowRect
->Inflate(CSSPixel::ToAppUnits(overflow
));
1524 LayoutDeviceIntCoord
Theme::GetScrollbarSize(const nsPresContext
* aPresContext
,
1525 StyleScrollbarWidth aWidth
,
1527 return GetScrollbarDrawing().GetScrollbarSize(aPresContext
, aWidth
, aOverlay
);
1530 nscoord
Theme::GetCheckboxRadioPrefSize() {
1531 return CSSPixel::ToAppUnits(kCheckboxRadioContentBoxSize
);
1535 UniquePtr
<ScrollbarDrawing
> Theme::ScrollbarStyle() {
1536 switch (StaticPrefs::widget_non_native_theme_scrollbar_style()) {
1538 return MakeUnique
<ScrollbarDrawingCocoa
>();
1540 return MakeUnique
<ScrollbarDrawingGTK
>();
1542 return MakeUnique
<ScrollbarDrawingAndroid
>();
1544 return MakeUnique
<ScrollbarDrawingWin
>();
1546 return MakeUnique
<ScrollbarDrawingWin11
>();
1550 // Default to native scrollbar style for each platform.
1552 if (IsWin11OrLater()) {
1553 return MakeUnique
<ScrollbarDrawingWin11
>();
1555 return MakeUnique
<ScrollbarDrawingWin
>();
1556 #elif MOZ_WIDGET_COCOA
1557 return MakeUnique
<ScrollbarDrawingCocoa
>();
1558 #elif MOZ_WIDGET_GTK
1559 return MakeUnique
<ScrollbarDrawingGTK
>();
1561 return MakeUnique
<ScrollbarDrawingAndroid
>();
1563 # error "Unknown platform, need scrollbar implementation."
1567 LayoutDeviceIntSize
Theme::GetMinimumWidgetSize(nsPresContext
* aPresContext
,
1569 StyleAppearance aAppearance
) {
1570 DPIRatio dpiRatio
= GetDPIRatio(aFrame
, aAppearance
);
1572 if (IsWidgetScrollbarPart(aAppearance
)) {
1573 return GetScrollbarDrawing().GetMinimumWidgetSize(aPresContext
, aAppearance
,
1577 LayoutDeviceIntSize result
;
1578 switch (aAppearance
) {
1579 case StyleAppearance::RangeThumb
:
1580 result
.SizeTo((kMinimumRangeThumbSize
* dpiRatio
).Rounded(),
1581 (kMinimumRangeThumbSize
* dpiRatio
).Rounded());
1583 case StyleAppearance::MozMenulistArrowButton
:
1584 result
.width
= (kMinimumDropdownArrowButtonWidth
* dpiRatio
).Rounded();
1586 case StyleAppearance::SpinnerUpbutton
:
1587 case StyleAppearance::SpinnerDownbutton
:
1588 result
.width
= (kMinimumSpinnerButtonWidth
* dpiRatio
).Rounded();
1589 result
.height
= (kMinimumSpinnerButtonHeight
* dpiRatio
).Rounded();
1597 nsITheme::Transparency
Theme::GetWidgetTransparency(
1598 nsIFrame
* aFrame
, StyleAppearance aAppearance
) {
1599 if (auto scrollbar
= GetScrollbarDrawing().GetScrollbarPartTransparency(
1600 aFrame
, aAppearance
)) {
1603 if (aAppearance
== StyleAppearance::Tooltip
) {
1604 // We draw a rounded rect, so we need transparency.
1605 return eTransparent
;
1607 return eUnknownTransparency
;
1611 Theme::WidgetStateChanged(nsIFrame
* aFrame
, StyleAppearance aAppearance
,
1612 nsAtom
* aAttribute
, bool* aShouldRepaint
,
1613 const nsAttrValue
* aOldValue
) {
1615 // Hover/focus/active changed. Always repaint.
1616 *aShouldRepaint
= true;
1618 // Check the attribute to see if it's relevant.
1619 // disabled, checked, dlgtype, default, etc.
1620 *aShouldRepaint
= false;
1621 if (aAttribute
== nsGkAtoms::disabled
|| aAttribute
== nsGkAtoms::checked
||
1622 aAttribute
== nsGkAtoms::selected
||
1623 aAttribute
== nsGkAtoms::visuallyselected
||
1624 aAttribute
== nsGkAtoms::menuactive
||
1625 aAttribute
== nsGkAtoms::sortDirection
||
1626 aAttribute
== nsGkAtoms::focused
|| aAttribute
== nsGkAtoms::_default
||
1627 aAttribute
== nsGkAtoms::open
|| aAttribute
== nsGkAtoms::hover
) {
1628 *aShouldRepaint
= true;
1636 Theme::ThemeChanged() { return NS_OK
; }
1638 bool Theme::WidgetAppearanceDependsOnWindowFocus(StyleAppearance aAppearance
) {
1639 return IsWidgetScrollbarPart(aAppearance
);
1642 nsITheme::ThemeGeometryType
Theme::ThemeGeometryTypeForWidget(
1643 nsIFrame
* aFrame
, StyleAppearance aAppearance
) {
1644 return eThemeGeometryTypeUnknown
;
1647 bool Theme::ThemeSupportsWidget(nsPresContext
* aPresContext
, nsIFrame
* aFrame
,
1648 StyleAppearance aAppearance
) {
1649 switch (aAppearance
) {
1650 case StyleAppearance::Radio
:
1651 case StyleAppearance::Checkbox
:
1652 case StyleAppearance::FocusOutline
:
1653 case StyleAppearance::Textarea
:
1654 case StyleAppearance::Textfield
:
1655 case StyleAppearance::Range
:
1656 case StyleAppearance::RangeThumb
:
1657 case StyleAppearance::ProgressBar
:
1658 case StyleAppearance::Progresschunk
:
1659 case StyleAppearance::Meter
:
1660 case StyleAppearance::Meterchunk
:
1661 case StyleAppearance::ScrollbarbuttonUp
:
1662 case StyleAppearance::ScrollbarbuttonDown
:
1663 case StyleAppearance::ScrollbarbuttonLeft
:
1664 case StyleAppearance::ScrollbarbuttonRight
:
1665 case StyleAppearance::ScrollbarthumbHorizontal
:
1666 case StyleAppearance::ScrollbarthumbVertical
:
1667 case StyleAppearance::ScrollbartrackHorizontal
:
1668 case StyleAppearance::ScrollbartrackVertical
:
1669 case StyleAppearance::ScrollbarHorizontal
:
1670 case StyleAppearance::ScrollbarVertical
:
1671 case StyleAppearance::Scrollcorner
:
1672 case StyleAppearance::Button
:
1673 case StyleAppearance::Listbox
:
1674 case StyleAppearance::Menulist
:
1675 case StyleAppearance::MenulistButton
:
1676 case StyleAppearance::NumberInput
:
1677 case StyleAppearance::MozMenulistArrowButton
:
1678 case StyleAppearance::SpinnerUpbutton
:
1679 case StyleAppearance::SpinnerDownbutton
:
1680 case StyleAppearance::Tooltip
:
1681 return !IsWidgetStyled(aPresContext
, aFrame
, aAppearance
);
1687 bool Theme::WidgetIsContainer(StyleAppearance aAppearance
) {
1688 switch (aAppearance
) {
1689 case StyleAppearance::MozMenulistArrowButton
:
1690 case StyleAppearance::Radio
:
1691 case StyleAppearance::Checkbox
:
1698 bool Theme::ThemeDrawsFocusForWidget(nsIFrame
*, StyleAppearance
) {
1702 bool Theme::ThemeNeedsComboboxDropmarker() { return true; }
1704 bool Theme::ThemeSupportsScrollbarButtons() {
1705 return GetScrollbarDrawing().ShouldDrawScrollbarButtons();
1708 } // namespace mozilla::widget